{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vadere EMA connector demo\n",
    "This notebook demonstrates the setup of a Vadere model connection. It uses an example Vadere model, made with Vadere 2.1. Before running the code yourself, please acquire a copy of Vadere from [the official Vadere website](https://www.vadere.org/download/). For more information on the use of the EMA Workbench, please refer to the [official EMA Workbench documentation](https://emaworkbench.readthedocs.io/en/latest/). This demo is based on the code provided on the documentation pages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1: imports\n",
    "The first step is to import the needed modules. This depends on the use and the type of analysis that is intended. The most important one here is the VadereModel from the model connectors. As said, please refer for more information on this to the [official EMA Workbench documentation](https://emaworkbench.readthedocs.io/en/latest/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ema_workbench import (\n",
    "    perform_experiments,\n",
    "    RealParameter,\n",
    "    ema_logging,\n",
    "    MultiprocessingEvaluator,\n",
    "    Samplers,\n",
    "    ScalarOutcome,\n",
    "    IntegerParameter,\n",
    "    RealParameter,\n",
    ")\n",
    "from ema_workbench.connectors.vadere import VadereModel\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: Setting up the model\n",
    "In this demonstration, we use a simple Vadere model example. The model includes two sources and one target, and spawns a number of pedestrians every second. The model uses the OSM locomotion implementation, and collects the following:\n",
    "\n",
    "- The average evacuation time -> stored in evacuationTime.txt\n",
    "- The average speed of all pedestrians each time step -> stored in speed.csv\n",
    "\n",
    "Note that the EMA connector assumes .txt files for scalar outcomes and .csv files for time series outcomes. Pleasure use these file types, and declare them explicitly in processor_files as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This model saves scalar results to a density.txt and speed.txt file.\n",
    "# Please acquire your own copy of Vadere, and place the vadere-console.jar in your model/scenarios directory\n",
    "# Note that the vadere model files and the console.jar should always be placed in a separate wd as the python runfile\n",
    "model = VadereModel(\n",
    "    \"demoModel\",\n",
    "    vadere_jar=\"vadere-console.jar\",\n",
    "    processor_files=[\"evacuationTime.txt\", \"speed.csv\"],\n",
    "    model_file=\"demo.scenario\",\n",
    "    wd=\"models/vadereModel/scenarios/\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set the number of replications to handle model stochasticity\n",
    "model.replications = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that for specifying model uncertainties (and potential levers), the Vadere model class can change any variable present in the model file (Vadere scenario). To realize this, an exact location to the variable of interest in the Vadere scenario file has to be specified. Vadere scenario files follow a nested dictionary structure. Therefore, the exact location of the variable should be passed in a list of argumentes, passed as one string. \n",
    "\n",
    "See the example below, that variates the following:\n",
    "\n",
    "- The number of spawned pedestrians from both sources\n",
    "- The mean of the free flow speed distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.uncertainties = [\n",
    "    IntegerParameter(\n",
    "        name=\"spawnNumberA\",\n",
    "        lower_bound=1,\n",
    "        upper_bound=50,\n",
    "        variable_name=['(\"scenario\", \"topography\", \"sources\", 0, \"spawnNumber\")'],\n",
    "    ),\n",
    "    IntegerParameter(\n",
    "        name=\"spawnNumberB\",\n",
    "        lower_bound=1,\n",
    "        upper_bound=50,\n",
    "        variable_name=['(\"scenario\", \"topography\", \"sources\", 1, \"spawnNumber\")'],\n",
    "    ),\n",
    "    RealParameter(\n",
    "        name=\"μFreeFlowSpeed\",\n",
    "        lower_bound=0.7,\n",
    "        upper_bound=1.5,\n",
    "        variable_name=[\n",
    "            '(\"scenario\", \"topography\", \"attributesPedestrian\", \"speedDistributionMean\")'\n",
    "        ],\n",
    "    ),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model outcomes can be specified by passing the exact name as present in the output file (speed.txt here). The naming convention depends on the used Vadere data processors, but usually follows the name + id of the processor. When in doubt, it is advised to do a demo Vadere run using the Vadere software and to inspect the generated output files. Note that we take the mean of the outcomes here, since we specified multiple replications. Note that we now only focus on scalar outcomes. See the end of this demo for timeseries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.outcomes = [\n",
    "    ScalarOutcome(name=\"evacuationTime\", variable_name=\"meanEvacuationTime-PID8\", function=np.mean)\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3: Performing experiments\n",
    "The last step is to perform experiment with the Vadere model. Both sequential runs as runs in parallel are supported. Note however that a Vadere run can use a lot of RAM, and using all available CPU cores can lead to performance issues in some cases. Additionally, one Vadere run is by default already multithreaded. It is therefore recommended to not use the full set of available processes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Logger EMA (DEBUG)>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# enable EMA logging\n",
    "ema_logging.log_to_stderr(ema_logging.INFO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[MainProcess/INFO] performing 2 scenarios * 1 policies * 1 model(s) = 2 experiments\n",
      "  0%|                                                    | 0/2 [00:00<?, ?it/s][MainProcess/INFO] performing experiments sequentially\n",
      "100%|████████████████████████████████████████████| 2/2 [01:03<00:00, 31.75s/it]\n",
      "[MainProcess/INFO] experiments finished\n"
     ]
    }
   ],
   "source": [
    "# run in sequential 2 experiments\n",
    "results_sequential = perform_experiments(model, scenarios=2, uncertainty_sampling=Samplers.LHS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[MainProcess/INFO] pool started with 4 workers\n",
      "[MainProcess/INFO] performing 4 scenarios * 1 policies * 1 model(s) = 4 experiments\n",
      "100%|████████████████████████████████████████████| 4/4 [00:37<00:00,  9.39s/it]\n",
      "[MainProcess/INFO] experiments finished\n",
      "[MainProcess/INFO] terminating pool\n",
      "[ForkPoolWorker-1/INFO] finalizing\n",
      "[ForkPoolWorker-4/INFO] finalizing\n",
      "[ForkPoolWorker-3/INFO] finalizing\n",
      "[ForkPoolWorker-2/INFO] finalizing\n"
     ]
    }
   ],
   "source": [
    "# run 6 experiments in parallel\n",
    "with MultiprocessingEvaluator(model, n_processes=-1) as evaluator:\n",
    "    experiments, outcomes = evaluator.perform_experiments(\n",
    "        scenarios=4, uncertainty_sampling=Samplers.LHS\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inspect the results\n",
    "we can now look at the results directly. For more extensive exploratory analysis methods, please refer to the [official EMA Workbench documentation](https://emaworkbench.readthedocs.io/en/latest/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>spawnNumberA</th>\n",
       "      <th>spawnNumberB</th>\n",
       "      <th>μFreeFlowSpeed</th>\n",
       "      <th>scenario</th>\n",
       "      <th>policy</th>\n",
       "      <th>model</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>25.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>0.838960</td>\n",
       "      <td>2</td>\n",
       "      <td>None</td>\n",
       "      <td>demoModel</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>46.0</td>\n",
       "      <td>19.0</td>\n",
       "      <td>1.413804</td>\n",
       "      <td>3</td>\n",
       "      <td>None</td>\n",
       "      <td>demoModel</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>28.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>0.942684</td>\n",
       "      <td>4</td>\n",
       "      <td>None</td>\n",
       "      <td>demoModel</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>1.111305</td>\n",
       "      <td>5</td>\n",
       "      <td>None</td>\n",
       "      <td>demoModel</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   spawnNumberA  spawnNumberB  μFreeFlowSpeed scenario policy      model\n",
       "0          25.0          33.0        0.838960        2   None  demoModel\n",
       "1          46.0          19.0        1.413804        3   None  demoModel\n",
       "2          28.0          11.0        0.942684        4   None  demoModel\n",
       "3           2.0          50.0        1.111305        5   None  demoModel"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "experiments.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>evacuationTime</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>14.268966</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>9.990154</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>11.673846</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>11.155385</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   evacuationTime\n",
       "0       14.268966\n",
       "1        9.990154\n",
       "2       11.673846\n",
       "3       11.155385"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(outcomes).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using time series data\n",
    "It is additionally possible to specify time series output data. See below for an example on how to do this. \n",
    "\n",
    "Note that this example now uses a different model class, since we do not want to average multiple scalar outcomes but are rather interested in a time series outcome. Hence, the SingleReplicationVadereModel is used. Now, the timeStep and average speeds are collected every step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ema_workbench import TimeSeriesOutcome\n",
    "from ema_workbench.connectors.vadere import SingleReplicationVadereModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This model saves scalar results to a density.txt and speed.txt file.\n",
    "# Please acquire your own copy of Vadere, and place the vadere-console.jar in your model/scenarios directory\n",
    "# Note that the vadere model files should always be placed in a separate wd as the python runfile\n",
    "model = SingleReplicationVadereModel(\n",
    "    \"demoModel\",\n",
    "    vadere_jar=\"vadere-console.jar\",\n",
    "    processor_files=[\"evacuationTime.txt\", \"speed.csv\"],\n",
    "    model_file=\"demo.scenario\",\n",
    "    wd=\"models/vadereModel/scenarios/\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.uncertainties = [\n",
    "    IntegerParameter(\n",
    "        name=\"spawnNumberA\",\n",
    "        lower_bound=1,\n",
    "        upper_bound=50,\n",
    "        variable_name=['(\"scenario\", \"topography\", \"sources\", 0, \"spawnNumber\")'],\n",
    "    ),\n",
    "    IntegerParameter(\n",
    "        name=\"spawnNumberB\",\n",
    "        lower_bound=1,\n",
    "        upper_bound=50,\n",
    "        variable_name=['(\"scenario\", \"topography\", \"sources\", 1, \"spawnNumber\")'],\n",
    "    ),\n",
    "    RealParameter(\n",
    "        name=\"μFreeFlowSpeed\",\n",
    "        lower_bound=0.7,\n",
    "        upper_bound=1.5,\n",
    "        variable_name=[\n",
    "            '(\"scenario\", \"topography\", \"attributesPedestrian\", \"speedDistributionMean\")'\n",
    "        ],\n",
    "    ),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.outcomes = [TimeSeriesOutcome(name=\"speedTime\", variable_name=\"areaSpeed-PID5\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[MainProcess/INFO] pool started with 4 workers\n",
      "[MainProcess/INFO] performing 4 scenarios * 1 policies * 1 model(s) = 4 experiments\n",
      "100%|████████████████████████████████████████████| 4/4 [00:07<00:00,  1.90s/it]\n",
      "[MainProcess/INFO] experiments finished\n",
      "[MainProcess/INFO] terminating pool\n",
      "[ForkPoolWorker-8/INFO] finalizing\n",
      "[ForkPoolWorker-5/INFO] finalizing\n",
      "[ForkPoolWorker-6/INFO] finalizing\n",
      "[ForkPoolWorker-7/INFO] finalizing\n"
     ]
    }
   ],
   "source": [
    "# Run experiments in parallel with all logical CPU cores except one\n",
    "with MultiprocessingEvaluator(model, n_processes=-1) as evaluator:\n",
    "    experiments, outcomes = evaluator.perform_experiments(\n",
    "        scenarios=4, uncertainty_sampling=Samplers.LHS\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 432x288 with 1 Axes>,\n",
       " {'speedTime': <AxesSubplot:title={'center':'speedTime'}, xlabel='Time', ylabel='speedTime'>})"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from ema_workbench.analysis.plotting import lines\n",
    "\n",
    "lines(experiments, outcomes, outcomes_to_show=\"speedTime\")"
   ]
  }
 ],
 "metadata": {
  "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.16"
  },
  "vscode": {
   "interpreter": {
    "hash": "2491a0d181165e383f6ed7a113ef0be9681b0648ff62905f130438e7b48194fd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}