doc/Notebooks/getting_started.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ifm_contrib - An Introduction\n",
    "\n",
    "*Contact: Alexander Renz - DHI Munich - are@dhigroup.com*\n",
    "\n",
    "\n",
    "***ifm_ contrib*** *is an Open-Source Extension of the IFM. It is written by practioners for practioners.\n",
    "It builds on top of the Standard FEFLOW IFM API which provides the elementary functions to access the model data. It therefore does not extend the functionality of the IFM in the sense of allowing to do something that was not possible before. It rather allows the use of the current functionality in a more productive and more intuitive way, mainly by making common processes available to the Data Science tools available in the Python Ecosystem, with (Geo)-Pandas being the most important tool.*\n",
    "\n",
    "*Development has started in September 2018 and the source code is maintained on DHI's github account. It should however be noted that at this stage DHI does not officially support this extension, which is provided \"as-is\" under the MIT license. There was no tracking of man-hours that went into the development, but telling by the number of uploaded code lines (60.000+) and commits (100+) on github stats, this is probably in the mid 3-digit range. At the same time, we are more than sure that productivity gain for the authors alone is going to pay back the investment.*\n",
    "\n",
    "*By publishing the code we hope to support the FEFLOW product as such, hoping for a productivity boost for the users and providing a counterpart to the `FloPy` library, the `ifm_contrib` counterpart in the MODFLOW world. And last not least, we are looking for others to contribute to this work, inside and outside DHI to make this a real community effort.*\n",
    "\n",
    "\n",
    "## FAQ\n",
    "\n",
    "**What is ifm_contrib?**\n",
    "\n",
    "+ **ifm_contrib** is an Open Source Extension Project for the FEFLOW Programming API Python IFM.\n",
    "+ **ifm_contrib** is code-compatible with the standard IFM.\n",
    "+ **ifm_contrib** adds extra API commands focussing on productivity in working with FEFLOW\n",
    "+ **ifm_contrib** syntax is kept close to workflows on the GUI for intuitivity\n",
    "\n",
    "**Installation**\n",
    "\n",
    "+ ifm_contrib requires FEFLOW version 7.2 or higher.\n",
    "+ ifm_contrib is published as a Python package for easy installation with `pip install ifm_contrib`.\n",
    "+ for the lastest development version, clone the repository from github `git clone http://github.com/dhi/ifm-contrib`\n",
    "\n",
    "**Legal**\n",
    "\n",
    "The code is published under the MIT license. It is free to use, share and modify. Users are encouraged to contribute their own code back to the main branch, however it is not a requirement. It is possible to create a private fork and make proprietary modifications. \n",
    "\n",
    "**Beta Status** \n",
    "\n",
    "The library is currently in a mature BETA-status, thus changes may be made that may break backwards compatibility, even though this has become uncommon since mid-2019.\n",
    "\n",
    "**Current Focus of Development**\n",
    "\n",
    "The main focus of development in 2018 through 2020 was to create an interoperability with the Python Ecosystem, namely (Geo-)Pandas and Matplotlib, which is now widely complete. Through the use of Jupyter Notebook, and can to a large degree replace the FEFLOW GUI for a number of tasks, especially during postprocessing.\n",
    "\n",
    "**Online Help**\n",
    "\n",
    "Its not a pretty one, but you can find an (unregularly updated) help system here:\n",
    "https://dhi.github.io/ifm_contrib/ifm_contrib.contrib_lib.html "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Highlights\n",
    "\n",
    "*ifm_contrib* in combination with Jupyter can improve productivity by a large amount as opposed to using the GUI alone. \n",
    "A few things you can do:\n",
    "\n",
    "**Visualize FEFLOW Results directly in Jupyter**\n",
    "\n",
    "Create inline plots with the look-and-feel of FEFLOWs directly within Jupyter. The plots can be exported as GeoDataFrames and saved to shape-files easily. *ifm_contrib* adds light support for coordinate systems to FEFLOW.\n",
    "\n",
    "<img src=\"highlights_map.png\" align=\"left\"> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Process FEFLOWs Time Series with Pandas**\n",
    "\n",
    "Time Series (aka Power functiosn) and History charts can be easily exported to pandas DataFrames. Automatic conversion to DateTime based on FEFLOWs Reference Time. In-Built Synchronization to observation point reference data.\n",
    "\n",
    "<img src=\"highlights_timeseries.png\" align=\"left\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pandas access to Nodal and Elemntal Data, Multi-Layer Wells, and many more**\n",
    "\n",
    "Just keep on reading..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation\n",
    "\n",
    "`ifm_contrib` can be run on \n",
    "+ **Python 3.5 or higher**. (Support for Python 2.7 is deprecated).\n",
    "+ **FEFLOW 7.2 or higher**, Python SDK must be installed.\n",
    "\n",
    "\n",
    "### Installation from GitHub\n",
    "\n",
    "`ifm_contrib` is continuosly and frequently updated (and still officially in beta-status). To get the latest version available, install `ifm_contrib` directly from github in one of the following ways."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Installation using git\n",
    "\n",
    "The recommended installation method is cloning the git-repository onto you local hard-drive. This allows for a convenient and frequent updates of the latest development version by pulling latest changes directly into the library.\n",
    "\n",
    "If you are not a user of git, see alternative installations below.\n",
    "\n",
    "A good target directory for cloning the repository is the python subfolder of FEFLOW (e.g. `C:\\Program Files\\DHI\\2019\\FEFLOW 7.2\\python`). This is where the classic IFM is installed. The folder is by default added to the Python search path by FEFLOW during installation.\n",
    "\n",
    "Note that under Windows the folder is protected and read-only. Make sure that you run your git-client as Administrator, or to remove the read-only protection under Windows before contuning. Note that if using Tortoise-Git, you have to allow writing permission before continuing.\n",
    "\n",
    "To clone the repository, open a command shell in the target directory and execute.\n",
    "\n",
    "  `git clone https://github.com/DHI/ifm_contrib.git`\n",
    "\n",
    "Of course you can use any other git-client if you prefer.\n",
    "\n",
    "Once cloning is successful, it is recommended to rename the folder `ifm_contrib-master` to `ifm_contrib`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Installation using  Zip-Folder\n",
    "  \n",
    "Download the Zip-Folder is the fastest way to install the latest version of ifm_contrib if you do not want to use git.\n",
    "Open https://github.com/dhi/ifm_contrib in your web-browser and choose **Clone or download** On the upper right corner, followed by: **Download ZIP**\n",
    "\n",
    "<img src=\"installation_zip.png\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Move the folder contained in the zip file to a local directory that is in your Python search path and rename it to `ifm_contrib`. A good choice is python subfolder of FEFLOW where the classic IFM is already placed (e.g. `C:\\Program Files\\DHI\\2019\\FEFLOW 7.2\\python`). This folder is by default been added to the Python search path by FEFLOW during installation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installation from PyPi\n",
    "\n",
    "#### Installation via pip\n",
    "\n",
    "Once `ifm_contrib` reaches a release state, it will be published on PiPy to allow installation using pip:\n",
    "\n",
    "  `pip install ifm_contrib`\n",
    "\n",
    "Due to the current beta-status **this option is still discouraged** as the version are not updated regularly. This will change in the future."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import and FEFLOW version\n",
    "\n",
    "`ifm_contrib` should now be found in the Python search path and can be imported as per below.\n",
    "Because **ifm_contrib is code-compatible to the standard IFM**, you can import it with this alias.\n",
    "\n",
    "Optionally, you can choose which version of the IFM API should be imported as the base ifm by setting an environment variable `FEFLOW_KERNEL_VERSION` and setting its value to the major FEFLOW version number (must be formatted as a string, e.g. `74` for FEFLOW 7.4. If no environment variable is set, the most recent installed FEFLOW version is used. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:35.844757Z",
     "start_time": "2021-02-12T17:08:35.455763Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FEFLOW Version: 7402\n"
     ]
    }
   ],
   "source": [
    "# optional: set FEFLOW version to work with\n",
    "import os\n",
    "os.environ['FEFLOW_KERNEL_VERSION'] = '74'\n",
    "\n",
    "# import ifm_contrib with alias ifm\n",
    "import ifm_contrib as ifm\n",
    "print(\"FEFLOW Version: {}\".format(ifm.getKernelVersion()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Namespace - Where do I find which Function?\n",
    "\n",
    "**Standard IFM calls**\n",
    "\n",
    "`ifm_contrib` inherits all commands of the classic IFM API, thus it is code-compatible with code written for the classic IFM ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:37.599381Z",
     "start_time": "2021-02-12T17:08:36.661038Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model has 959 elements.\n"
     ]
    }
   ],
   "source": [
    "# set the license to Viewer (no license required for postprocessing)\n",
    "ifm.forceLicense(\"Viewer\")\n",
    "\n",
    "# load a model and do some regular stuff with it\n",
    "doc = ifm.loadDocument(\"../../unittests/models/example_2D.dac\")\n",
    "print(f\"The model has {doc.getNumberOfElements()} elements.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ifm_contrib calls**\n",
    "\n",
    "However **ifm_contrib adds additional API features**. Most of these are found in a separate sub-namespace of the IfmDocument object called `doc.c.<command>`. The code below is a method to retrieve a data-frame with the head-observations of a model by calling `doc.c.hist.df.HEAD` and plotting it using the DataFraes `.plot()`-method.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:38.193241Z",
     "start_time": "2021-02-12T17:08:37.974024Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1edbfaaa5c0>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "doc.c.hist.df.HEAD.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The features are classified by their usage, following roughly the rationale as they appear in FEFLOW's GUI:\n",
    "\n",
    "+ `doc.c.plot` : plot maps using matplotlib, similar to FEFLOWs slice view.\n",
    "+ `doc.c.hist` : get history chart data\n",
    "+ `doc.c.mesh` : get model data (nodal, elemental, dfe, multi-layer wells, etc.)\n",
    "+ `doc.c.ts` : get time series data\n",
    "+ `doc.c.obs` : get observation points data\n",
    "+ `doc.c.sel` : get selection data\n",
    "+ `doc.c.content` : get elemental content data\n",
    "\n",
    "An individual introduction for each of them is provided further below.\n",
    "\n",
    "**Methods for Vanilla Python (if using standard libraries only)**\n",
    "\n",
    "The direct member methods of these objects return results that can be used using Python standard libraries.\n",
    "\n",
    "For example, `doc.c.sel.getSelectionNames` returns the names of the selections stored in the model as a plain Python list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:39.241238Z",
     "start_time": "2021-02-12T17:08:39.234238Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['upper_half', 'conversiontest_el']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.c.sel.getSelectionNames(seltype=ifm.Enum.SEL_ELEMS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Methods for Pandas**\n",
    "\n",
    "The recommended use of ifm_contrib is in conjunction with the well-known Python DataScience ecosystem, namely `pandas`, `geopandas` (See section *Plotting* for `matplotlib`).\n",
    "\n",
    "In this case, ifm_cotrib common return format are pandas.DataFrame objects. The respective methods are available in the `.df` (stands for DataFrame) namespace in each component, e.g. for the case of selections `doc.c.sel.df.selections`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:40.319885Z",
     "start_time": "2021-02-12T17:08:40.293885Z"
    }
   },
   "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>SEL_TYPE</th>\n",
       "      <th>SEL_ENUM</th>\n",
       "      <th>SEL_ID</th>\n",
       "      <th>N_ITEMS</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>selection_name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>upper_half</th>\n",
       "      <td>elements</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>420</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>conversiontest_el</th>\n",
       "      <td>elements</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   SEL_TYPE  SEL_ENUM  SEL_ID  N_ITEMS\n",
       "selection_name                                        \n",
       "upper_half         elements         1       0      420\n",
       "conversiontest_el  elements         1       1        2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.c.sel.df.selections(seltype=ifm.Enum.SEL_ELEMS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that ifm_contrib adds additional information, like in this case the number of elements, for easier access to information.\n",
    "\n",
    "**Method for GeoPandas**\n",
    "\n",
    "For methods returning geographic information, there is also a `.gdf` namespace that returns the desired information as a GeoDataFrame that contains the geometry of a feature to allow plotting and spatial operation.\n",
    "\n",
    "For example, observation points `doc.c.obs.gdf.obspoints` method returns a GeoDataFrame that can be used like a regular Dataframe,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:41.610497Z",
     "start_time": "2021-02-12T17:08:41.307500Z"
    }
   },
   "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>label</th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>z</th>\n",
       "      <th>node</th>\n",
       "      <th>h</th>\n",
       "      <th>conc</th>\n",
       "      <th>shape</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>myObsPoint1</td>\n",
       "      <td>422.358098</td>\n",
       "      <td>833.017547</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.228757</td>\n",
       "      <td>NaN</td>\n",
       "      <td>POINT (422.358 833.018)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>myObsPoint2</td>\n",
       "      <td>578.870531</td>\n",
       "      <td>561.335589</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.417063</td>\n",
       "      <td>NaN</td>\n",
       "      <td>POINT (578.871 561.336)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>myObsPoint3</td>\n",
       "      <td>192.019047</td>\n",
       "      <td>463.884452</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>4.731053</td>\n",
       "      <td>NaN</td>\n",
       "      <td>POINT (192.019 463.884)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          label           x           y    z  node         h  conc  \\\n",
       "id                                                                   \n",
       "0   myObsPoint1  422.358098  833.017547  0.0   NaN  3.228757   NaN   \n",
       "1   myObsPoint2  578.870531  561.335589  0.0   NaN  3.417063   NaN   \n",
       "2   myObsPoint3  192.019047  463.884452  0.0   NaN  4.731053   NaN   \n",
       "\n",
       "                      shape  \n",
       "id                           \n",
       "0   POINT (422.358 833.018)  \n",
       "1   POINT (578.871 561.336)  \n",
       "2   POINT (192.019 463.884)  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.c.obs.gdf.obspoints()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... but can also be shown in a Jupyter Notebook as a geometric shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:42.608165Z",
     "start_time": "2021-02-12T17:08:42.362975Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1edc1385a58>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "doc.c.obs.gdf.obspoints().plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Features \n",
    "\n",
    "In the following, the most important features are explained. We will discuss the main objects one-by-one.\n",
    "Note that its quite rare that the author typing this line has the time to update this document, so always assume that this not even more features may be implemented by the time you read this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Access Model Properties\n",
    "\n",
    "One of the most commonly used features of ifm_contrib is to query data that is related to mesh items and basically everything that you would see in the *Data Panel* of the GIU.\n",
    "\n",
    "These methods can be found below\n",
    "\n",
    "+ `doc.c.mesh`\n",
    "+ `doc.c.mesh.df`\n",
    "+ `doc.c.mesh.gdf`\n",
    "\n",
    "Note: Most of the time you want to use *(geo)pandas-use* features only here you can query more than just the basic information. Be careful with the corresponding *geopandas* options, computation is significant if querying large tables like nodes or elements.\n",
    "\n",
    "Items you can query for are:\n",
    "\n",
    "+ `doc.c.df.nodes` / `doc.c.df.elements`: nodal and elemental data, probably the most used functions\n",
    "+ `doc.c.df.elements` / `doc.c.df.faces`: data related to faces and elements (not much there, though)\n",
    "+ `doc.c.df.dfe` Properties of Discrete Feature Elements\n",
    "+ `doc.c.df.mlw` Properties of Multi-Layer Wells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nodal and Elemental Data\n",
    "\n",
    "`doc.c.mesh.df.nodes()` and `doc.c.mesh.df.elements()` returns a DataFrame with basic information on these properties if called without any parameters (showing first 3 lines). Note that coordinates are provided in global coordinates unless `global_cos=False` is set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:45.526886Z",
     "start_time": "2021-02-12T17:08:45.509886Z"
    }
   },
   "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>SLICE</th>\n",
       "      <th>TOP_NODE</th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NODE</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>165.454856</td>\n",
       "      <td>1029.189591</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>136.731283</td>\n",
       "      <td>1003.845262</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>108.007710</td>\n",
       "      <td>978.500933</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     SLICE TOP_NODE           X            Y\n",
       "NODE                                        \n",
       "0     None     None  165.454856  1029.189591\n",
       "1     None     None  136.731283  1003.845262\n",
       "2     None     None  108.007710   978.500933"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_nodes = doc.c.mesh.df.nodes()\n",
    "df_nodes.head(n=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To query more usefull data from the model, we want to add further columns to this table with the corresponding nodal data. \n",
    "\n",
    "**Model Properties**\n",
    "\n",
    "The below example adds a colum with the nodal hydraulic head value to the DataFrame by calling the parameter `par=`. The parameter is one of the constants defined in the `ifm.Enum` object, in which parameters are marked with a leading `P_` (e.g., `ifm.Enum.P_HEAD` denotes the hydraulic head)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:46.452288Z",
     "start_time": "2021-02-12T17:08:46.429260Z"
    }
   },
   "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>SLICE</th>\n",
       "      <th>TOP_NODE</th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "      <th>400</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NODE</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>165.454856</td>\n",
       "      <td>1029.189591</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>136.731283</td>\n",
       "      <td>1003.845262</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>108.007710</td>\n",
       "      <td>978.500933</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     SLICE TOP_NODE           X            Y  400\n",
       "NODE                                             \n",
       "0     None     None  165.454856  1029.189591  0.0\n",
       "1     None     None  136.731283  1003.845262  NaN\n",
       "2     None     None  108.007710   978.500933  NaN"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_nodes= doc.c.mesh.df.nodes(par=ifm.Enum.P_HEAD)\n",
    "df_nodes.head(n=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As this is not very readable, it is usually better to provide human-friendly column names when calling the method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:47.376449Z",
     "start_time": "2021-02-12T17:08:47.352431Z"
    }
   },
   "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>SLICE</th>\n",
       "      <th>TOP_NODE</th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "      <th>HEAD</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NODE</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>165.454856</td>\n",
       "      <td>1029.189591</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>136.731283</td>\n",
       "      <td>1003.845262</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>108.007710</td>\n",
       "      <td>978.500933</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     SLICE TOP_NODE           X            Y  HEAD\n",
       "NODE                                              \n",
       "0     None     None  165.454856  1029.189591   0.0\n",
       "1     None     None  136.731283  1003.845262   NaN\n",
       "2     None     None  108.007710   978.500933   NaN"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_nodes= doc.c.mesh.df.nodes(par={\"HEAD\": ifm.Enum.P_HEAD})\n",
    "df_nodes.head(n=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This also allows you query more than one parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:48.360487Z",
     "start_time": "2021-02-12T17:08:48.341487Z"
    }
   },
   "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>LAYER</th>\n",
       "      <th>TOP_ELEMENT</th>\n",
       "      <th>Transmissivity</th>\n",
       "      <th>Matrix Compressibility</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ELEMENT</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0001</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        LAYER TOP_ELEMENT  Transmissivity  Matrix Compressibility\n",
       "ELEMENT                                                          \n",
       "0        None        None             1.0                  0.0001\n",
       "1        None        None             1.0                  0.0001\n",
       "2        None        None             1.0                  0.0001"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_elements= doc.c.mesh.df.elements(par={\"Transmissivity\": ifm.Enum.P_TRANS,\n",
    "                                        \"Matrix Compressibility\" : ifm.Enum.P_COMP})\n",
    "df_elements.head(n=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**User Distributions and Expressions** \n",
    "\n",
    "In a very similar way, User distributions and Expressions can be queried using the `distr=` and `expr=` parmeters, respectively. Isage is non-exclusive with other queries. The parameter expected is the name of distribution/expression, either as a string or a list of strings if multiple queries are required. Note that dict-style renaming is not implemented yet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:49.280146Z",
     "start_time": "2021-02-12T17:08:49.255122Z"
    }
   },
   "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>ID</th>\n",
       "      <th>Name</th>\n",
       "      <th>user_type</th>\n",
       "      <th>item_type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>elemental_test</td>\n",
       "      <td>DISTRIBUTION</td>\n",
       "      <td>ELEMENTAL</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>nodal_test</td>\n",
       "      <td>DISTRIBUTION</td>\n",
       "      <td>NODAL</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>elemental_expr_test</td>\n",
       "      <td>EXPRESSION</td>\n",
       "      <td>ELEMENTAL</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>nodal_expr_test</td>\n",
       "      <td>EXPRESSION</td>\n",
       "      <td>NODAL</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ID                 Name     user_type  item_type\n",
       "0   0       elemental_test  DISTRIBUTION  ELEMENTAL\n",
       "0   0           nodal_test  DISTRIBUTION      NODAL\n",
       "0   0  elemental_expr_test    EXPRESSION  ELEMENTAL\n",
       "0   0      nodal_expr_test    EXPRESSION      NODAL"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Have a quick look at the available user distributions in the model:\n",
    "doc.c.user.df.distributions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:49.324128Z",
     "start_time": "2021-02-12T17:08:49.283096Z"
    }
   },
   "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>SLICE</th>\n",
       "      <th>TOP_NODE</th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "      <th>HEAD</th>\n",
       "      <th>nodal_expr_test</th>\n",
       "      <th>nodal_test</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NODE</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>165.454856</td>\n",
       "      <td>1029.189591</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>136.731283</td>\n",
       "      <td>1003.845262</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>108.007710</td>\n",
       "      <td>978.500933</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     SLICE TOP_NODE           X            Y  HEAD  nodal_expr_test  \\\n",
       "NODE                                                                  \n",
       "0     None     None  165.454856  1029.189591   0.0              1.0   \n",
       "1     None     None  136.731283  1003.845262   NaN              1.0   \n",
       "2     None     None  108.007710   978.500933   NaN              1.0   \n",
       "\n",
       "      nodal_test  \n",
       "NODE              \n",
       "0            1.0  \n",
       "1            1.0  \n",
       "2            1.0  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_nodes = doc.c.mesh.df.nodes(par={\"HEAD\" : ifm.Enum.P_HEAD}, distr=\"nodal_test\", expr=[\"nodal_expr_test\"])\n",
    "df_nodes.head(n=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**velocity, budget, content, centroids**\n",
    "\n",
    "These methods are also used for computational results that deliver nodal or elemental results, respectively.\n",
    "\n",
    "Additional possible queries are:\n",
    "+ `doc.c.mesh.df.elements(content=Ture)`: Add elemental content components\n",
    "+ `doc.c.mesh.df.elements(centroids=True)`: Add centroid coordinates\n",
    "+ `doc.c.mesh.df.nodes(budget=True)`: Add nodal budget components\n",
    "+ `doc.c.mesh.df.nodes(content=True)`: Add nodal velocity components\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Filtering by Selection or Layer/Slice, and using GeoPandas**\n",
    "\n",
    "It is possible to filter the output by a certain selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:51.398848Z",
     "start_time": "2021-02-12T17:08:51.380870Z"
    }
   },
   "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>SLICE</th>\n",
       "      <th>TOP_NODE</th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NODE</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>570</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>254.321772</td>\n",
       "      <td>533.356754</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>430</th>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>380.547981</td>\n",
       "      <td>757.171943</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     SLICE TOP_NODE           X           Y\n",
       "NODE                                       \n",
       "570   None     None  254.321772  533.356754\n",
       "430   None     None  380.547981  757.171943"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.c.mesh.df.nodes(selection=\"abstraction_rate\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or by a slice number (`doc.c.mesh.df.nodes(slice=1)` or, respectivel, layer number `doc.c.mesh.df.elements(layer=1)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Writing Parameter and User Data back to to FEFLOW**\n",
    "\n",
    "ifm_contrib does not provide methods of setting parameter values in FEFLOW, because the classic ifm library allow  vectorized parameter setting using the following functions:\n",
    "\n",
    "+ `doc.setParamValues`\n",
    "+ `doc.setNodalRefDistrValue`\n",
    "+ `doc.setElementalRefDistrValue`\n",
    "\n",
    "The following workflow allows manipulating model data conveniently with pandas using concise code:\n",
    "\n",
    "+ read the existing data (e.g. `df = doc.c.mesh.df.elements(par={\"CONDX\" : ifm.Enum.P_CONDX}`. Make sure to read data from all nodes/elements)\n",
    "+ do the desired operations on the data (e.g., set a new value for a specific selection)\n",
    "+ Use `doc.setParamValues(ifm.Enum.P_CONDX, list(df.CONDX)` to write back the manipulated data in a vectorized fashion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selections (Items Sets)\n",
    "\n",
    "The methods of the `doc.c.sel` object are facilitating the usage of selections and its items.\n",
    "\n",
    "As opposed to the corresponding functions in standard ifm, selections are called by their given name directly, thus that it is not necessary to make seperate queries for the user distribution id.\n",
    "\n",
    "**Get list of selections**\n",
    "\n",
    "Lets start by checking which selections are in the model. `doc.c.sel.selections()` returns a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:54.376956Z",
     "start_time": "2021-02-12T17:08:54.370957Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['west', 'east', 'abstraction_rate', 'upper_half', 'conversiontest_el']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.c.sel.selections()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "it may be more useful to call the corresponding pandas method, which provides more information:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:55.448257Z",
     "start_time": "2021-02-12T17:08:55.402035Z"
    }
   },
   "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>SEL_TYPE</th>\n",
       "      <th>SEL_ENUM</th>\n",
       "      <th>SEL_ID</th>\n",
       "      <th>N_ITEMS</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>selection_name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>west</th>\n",
       "      <td>nodes</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>east</th>\n",
       "      <td>nodes</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>abstraction_rate</th>\n",
       "      <td>nodes</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>upper_half</th>\n",
       "      <td>elements</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>420.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>conversiontest_el</th>\n",
       "      <td>elements</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   SEL_TYPE  SEL_ENUM SEL_ID  N_ITEMS\n",
       "selection_name                                       \n",
       "west                  nodes         0      0     20.0\n",
       "east                  nodes         0      1     12.0\n",
       "abstraction_rate      nodes         0      2      2.0\n",
       "upper_half         elements         1      0    420.0\n",
       "conversiontest_el  elements         1      1      2.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.c.sel.df.selections()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Get item numbers of selections**\n",
    "\n",
    "Using the selection name, we can now query the items using `doc.c.sel.list()` (returns a Python list) or `doc.c.sel.set()` (returns a Python set)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:56.540278Z",
     "start_time": "2021-02-12T17:08:56.534272Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.c.sel.list(\"west\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lists are particularly useful to run queries on pandas dataframes:\n",
    "\n",
    "The following example uses `doc.c.mesh.df.elements` to query an element list including the elemental Tranmissivity values, and then uses `doc.c.sel.list` to query only those elements in the \"upper_half\" selection. \n",
    "We finally plot a histogram of the values queried this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:57.770881Z",
     "start_time": "2021-02-12T17:08:57.572937Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_elements = doc.c.mesh.df.elements(par=ifm.Enum.P_TRANS).loc[doc.c.sel.list(\"upper_half\")]\n",
    "df_elements.plot.hist(label=\"Transmissivity\")\n",
    "\n",
    "# OK, let's load the matplotlib to make this figure pretty ...\n",
    "import matplotlib.pyplot as plt\n",
    "#matplotlib inline\n",
    "plt.xlabel(u\"Transmissvity [m²/d]\")\n",
    "plt.ylabel(u\"Number of Elements\")\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next examples illustrates how this enables to do calculation with very concise syntax.\n",
    "The line below calculates the water balance for the western border of the model (nodes in selection \"west\"):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:58.629127Z",
     "start_time": "2021-02-12T17:08:58.609123Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-12.45188231530436"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.c.mesh.df.nodes(budget=True).loc[doc.c.sel.list(\"west\")].budget_flow_bc.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Create, clear, update and convert selections**\n",
    "\n",
    "The following functions can replace their standard ifm correspondants, as they allow to work with selection names and item lists more conveniently, they also resemble the context menu options of the Selection Panel of the GUI:\n",
    "\n",
    "+ `doc.c.sel.create` create a selection from a list of elements\n",
    "+ `doc.c.sel.clear` clear the selection\n",
    "+ `doc.c.sel.convert` convert the selection to a different type\n",
    "+ `doc.c.sel.update` set the givn list of items as the new selection\n",
    "\n",
    "The below example creates a new elemental selection with all elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:08:59.651899Z",
     "start_time": "2021-02-12T17:08:59.606901Z"
    }
   },
   "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>SEL_TYPE</th>\n",
       "      <th>SEL_ENUM</th>\n",
       "      <th>SEL_ID</th>\n",
       "      <th>N_ITEMS</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>selection_name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>west</th>\n",
       "      <td>nodes</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>20.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>east</th>\n",
       "      <td>nodes</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>abstraction_rate</th>\n",
       "      <td>nodes</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>upper_half</th>\n",
       "      <td>elements</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>420.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>conversiontest_el</th>\n",
       "      <td>elements</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All_Elements</th>\n",
       "      <td>elements</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>959.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   SEL_TYPE  SEL_ENUM SEL_ID  N_ITEMS\n",
       "selection_name                                       \n",
       "west                  nodes         0      0     20.0\n",
       "east                  nodes         0      1     12.0\n",
       "abstraction_rate      nodes         0      2      2.0\n",
       "upper_half         elements         1      0    420.0\n",
       "conversiontest_el  elements         1      1      2.0\n",
       "All_Elements       elements         1      2    959.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "doc.c.sel.create(ifm.Enum.SEL_ELEMENTAL, \"All_Elements\", \n",
    "                 itemlist=range(doc.getNumberOfElements()),\n",
    "                 overwrite_existing=True)\n",
    "doc.c.sel.df.selections()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**intersect, add, subtract selections**\n",
    "\n",
    "Set operations as they appear in the GUI are not explicitely implemented (feel free to do so!). Instead, we can use the `doc.c.sel.set` command to retrieve the item numbers as a Python set, which allows to easily perform set operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:00.643719Z",
     "start_time": "2021-02-12T17:09:00.637716Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "420"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# intersection\n",
    "len(doc.c.sel.set(\"upper_half\") & doc.c.sel.set(\"All_Elements\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:00.663721Z",
     "start_time": "2021-02-12T17:09:00.646719Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "959"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# union\n",
    "len(doc.c.sel.set(\"upper_half\") | doc.c.sel.set(\"All_Elements\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Time Series (Output / Histories)\n",
    "\n",
    "Probably one of the most important results from FEFLOW are the history charts, with continuous results on observation points, budgets, etc. This is probably the most heavily used feature when you are using ifm_contrib for postprocessing.\n",
    "\n",
    "**Basic Usage**\n",
    "\n",
    "As time series are best processed using pandas, ifm_contrib provides fast access to all histories in DataFrame through a single method `doc.c.hist.df.history()`. The following example returns a DataFrame of the hydraulic head at the observations points (last 3 entries shown):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:01.738349Z",
     "start_time": "2021-02-12T17:09:01.712074Z"
    }
   },
   "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>myObsPoint1</th>\n",
       "      <th>myObsPoint2</th>\n",
       "      <th>myObsPoint3</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Simulation Time</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>9.353301</th>\n",
       "      <td>3.032246</td>\n",
       "      <td>3.161879</td>\n",
       "      <td>4.534319</td>\n",
       "      <td>3.032246</td>\n",
       "      <td>3.161879</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9.977686</th>\n",
       "      <td>3.222012</td>\n",
       "      <td>3.408310</td>\n",
       "      <td>4.723575</td>\n",
       "      <td>3.222012</td>\n",
       "      <td>3.408310</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10.000000</th>\n",
       "      <td>3.228757</td>\n",
       "      <td>3.417063</td>\n",
       "      <td>4.731052</td>\n",
       "      <td>3.228757</td>\n",
       "      <td>3.417063</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 myObsPoint1  myObsPoint2  myObsPoint3         1         2\n",
       "Simulation Time                                                           \n",
       "9.353301            3.032246     3.161879     4.534319  3.032246  3.161879\n",
       "9.977686            3.222012     3.408310     4.723575  3.222012  3.408310\n",
       "10.000000           3.228757     3.417063     4.731052  3.228757  3.417063"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_head = doc.c.hist.df.history(ifm.Enum.HIST_HEAD)\n",
    "df_head.tail(n=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because this is such a common operation, ifm_contrib also allows a short syntax for this kind of call (however it does not allow any customization shown further below):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:02.704319Z",
     "start_time": "2021-02-12T17:09:02.684322Z"
    }
   },
   "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>myObsPoint1</th>\n",
       "      <th>myObsPoint2</th>\n",
       "      <th>myObsPoint3</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Simulation Time</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>9.353301</th>\n",
       "      <td>3.032246</td>\n",
       "      <td>3.161879</td>\n",
       "      <td>4.534319</td>\n",
       "      <td>3.032246</td>\n",
       "      <td>3.161879</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9.977686</th>\n",
       "      <td>3.222012</td>\n",
       "      <td>3.408310</td>\n",
       "      <td>4.723575</td>\n",
       "      <td>3.222012</td>\n",
       "      <td>3.408310</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10.000000</th>\n",
       "      <td>3.228757</td>\n",
       "      <td>3.417063</td>\n",
       "      <td>4.731052</td>\n",
       "      <td>3.228757</td>\n",
       "      <td>3.417063</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 myObsPoint1  myObsPoint2  myObsPoint3         1         2\n",
       "Simulation Time                                                           \n",
       "9.353301            3.032246     3.161879     4.534319  3.032246  3.161879\n",
       "9.977686            3.222012     3.408310     4.723575  3.222012  3.408310\n",
       "10.000000           3.228757     3.417063     4.731052  3.228757  3.417063"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_head = doc.c.hist.df.HEAD\n",
    "df_head.tail(n=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Simulation Time and Calendar Date**\n",
    "\n",
    "The index of the DataFrame being returned can either be of float type (relate to the simulation time in days - *time axis*) or of datetime type (calendar date - *calendar axis*).\n",
    "\n",
    "Unless you force a time axis (`doc.c.hist.df.history(ifm.Enum.HIST_HEAD, force_time_axis=True)`), ifm_contrib will return a calendar axis if a reference time is set in FEFLOW (can be set in Problem Settings in the GUI, or through the IFM):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:03.911319Z",
     "start_time": "2021-02-12T17:09:03.719320Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1edc14cc4e0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# do the query (no reference date is set in the model at this point)\n",
    "df_time_axis = doc.c.hist.df.history(ifm.Enum.HIST_HEAD)\n",
    "df_time_axis.plot(title=\"with time axis\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:04.139531Z",
     "start_time": "2021-02-12T17:09:03.914319Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1edc1577a58>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# set the reference date\n",
    "from datetime import datetime\n",
    "doc.setReferenceTime(datetime(2020, 5, 1))\n",
    "\n",
    "# repeat the query\n",
    "df_calendar_axis = doc.c.hist.df.history(ifm.Enum.HIST_HEAD)\n",
    "df_calendar_axis.plot(title=\"with calendar axis\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sync to a different index**\n",
    "\n",
    "When comparing observation data with simulation results, it is a common necessesity to be able to map the model results onto the observation time index. For convenience, ifm_contrib has an in-built feature for this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:04.869664Z",
     "start_time": "2021-02-12T17:09:04.859665Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2020-05-01', '2020-05-02', '2020-05-03', '2020-05-04',\n",
       "               '2020-05-05', '2020-05-06', '2020-05-07', '2020-05-08',\n",
       "               '2020-05-09', '2020-05-10'],\n",
       "              dtype='datetime64[ns]', freq='D')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a DateTime index with daily time steps\n",
    "import pandas as pd\n",
    "observation_index = pd.date_range(datetime(2020, 5, 1), datetime(2020,5,10), freq=\"D\")\n",
    "observation_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:04.921950Z",
     "start_time": "2021-02-12T17:09:04.871664Z"
    }
   },
   "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>myObsPoint1</th>\n",
       "      <th>myObsPoint2</th>\n",
       "      <th>myObsPoint3</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-05-01</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-02</th>\n",
       "      <td>0.221911</td>\n",
       "      <td>-0.014134</td>\n",
       "      <td>0.833540</td>\n",
       "      <td>0.221911</td>\n",
       "      <td>-0.014134</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-03</th>\n",
       "      <td>0.578335</td>\n",
       "      <td>0.067372</td>\n",
       "      <td>1.665075</td>\n",
       "      <td>0.578335</td>\n",
       "      <td>0.067372</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-04</th>\n",
       "      <td>0.713917</td>\n",
       "      <td>0.370775</td>\n",
       "      <td>2.251835</td>\n",
       "      <td>0.713917</td>\n",
       "      <td>0.370775</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-05</th>\n",
       "      <td>0.793745</td>\n",
       "      <td>0.660354</td>\n",
       "      <td>2.637627</td>\n",
       "      <td>0.793745</td>\n",
       "      <td>0.660354</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-06</th>\n",
       "      <td>1.214472</td>\n",
       "      <td>1.149929</td>\n",
       "      <td>3.176443</td>\n",
       "      <td>1.214472</td>\n",
       "      <td>1.149929</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-07</th>\n",
       "      <td>1.722414</td>\n",
       "      <td>1.565315</td>\n",
       "      <td>3.576743</td>\n",
       "      <td>1.722414</td>\n",
       "      <td>1.565315</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-08</th>\n",
       "      <td>2.130138</td>\n",
       "      <td>1.974632</td>\n",
       "      <td>3.896055</td>\n",
       "      <td>2.130138</td>\n",
       "      <td>1.974632</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-09</th>\n",
       "      <td>2.644993</td>\n",
       "      <td>2.579562</td>\n",
       "      <td>4.225660</td>\n",
       "      <td>2.644993</td>\n",
       "      <td>2.579562</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-10</th>\n",
       "      <td>2.964601</td>\n",
       "      <td>3.071412</td>\n",
       "      <td>4.477504</td>\n",
       "      <td>2.964601</td>\n",
       "      <td>3.071412</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            myObsPoint1  myObsPoint2  myObsPoint3         1         2\n",
       "2020-05-01     0.000000     0.000000     0.000000  0.000000  0.000000\n",
       "2020-05-02     0.221911    -0.014134     0.833540  0.221911 -0.014134\n",
       "2020-05-03     0.578335     0.067372     1.665075  0.578335  0.067372\n",
       "2020-05-04     0.713917     0.370775     2.251835  0.713917  0.370775\n",
       "2020-05-05     0.793745     0.660354     2.637627  0.793745  0.660354\n",
       "2020-05-06     1.214472     1.149929     3.176443  1.214472  1.149929\n",
       "2020-05-07     1.722414     1.565315     3.576743  1.722414  1.565315\n",
       "2020-05-08     2.130138     1.974632     3.896055  2.130138  1.974632\n",
       "2020-05-09     2.644993     2.579562     4.225660  2.644993  2.579562\n",
       "2020-05-10     2.964601     3.071412     4.477504  2.964601  3.071412"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# then we inject this in\n",
    "df_observation_axis = doc.c.hist.df.history(ifm.Enum.HIST_HEAD, sync_to_index=observation_index)\n",
    "df_observation_axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:05.191942Z",
     "start_time": "2021-02-12T17:09:04.924950Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1edc1625710>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the curves side by side\n",
    "\n",
    "ax1 = df_calendar_axis[[\"myObsPoint1\", \"myObsPoint2\"]].plot(style=\".-\")\n",
    "df_observation_axis[[\"myObsPoint1\", \"myObsPoint2\"]].plot(ax=ax1, style=\"x\", color=\"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: if you find a bug in the code, please put in a ticket on https://github.com/dhi/ifm_contrib/issues. Thank you."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Time Series (Input / Power Functions)\n",
    "\n",
    "The main difference between History charts and Time Series (aka power Functions) is that the former ones are synchronous (sharing the same time axis which are the time steps of the simulation run), while the latter one have individual time indices. This is why Time Series and histories are handled somewhat differently.\n",
    "\n",
    "**List of Time Series**\n",
    "\n",
    "ifm_contrib provides a few business functions mainly for convenience. The most important is `doc.c.ts.df.info()` which returns a DataFrame with information of the models time series. (`doc.c.ts.info()` is the equivalent function for vanilla python):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:06.891748Z",
     "start_time": "2021-02-12T17:09:06.876740Z"
    }
   },
   "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>comment</th>\n",
       "      <th>no_point</th>\n",
       "      <th>interpolation_kind</th>\n",
       "      <th>is_cyclic</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tsid</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>weel_A</td>\n",
       "      <td>8</td>\n",
       "      <td>2</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>well B</td>\n",
       "      <td>8</td>\n",
       "      <td>2</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>gap_example</td>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          comment  no_point  interpolation_kind  is_cyclic\n",
       "tsid                                                      \n",
       "10         weel_A         8                   2      False\n",
       "11         well B         8                   2      False\n",
       "20    gap_example         5                   2      False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.c.ts.df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Content of Time Series**\n",
    "\n",
    "To retrieve the time series itself, use the `doc.c.ts.df.points` method. You can choose the time series by its unique ID or by its comment.\n",
    "\n",
    "**Note 1:** A gap in the time series is denothed by a `NaN` value.\n",
    "\n",
    "**Note 2:** With regard to a time axis or calendar axis, `doc.c.ts.df.points` behaves equivalent to `doc.c.hist.df.history`\n",
    "\n",
    "**WARNING:** If calling by the comment, make sure that this is a unique identifier. ifm_contrib with rise a `RunTimeError` otherwise.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-12T17:09:07.889048Z",
     "start_time": "2021-02-12T17:09:07.867050Z"
    }
   },
   "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>Values</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Simulation Time</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-05-01 00:00:00</th>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-02 00:00:00</th>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-03 00:00:00</th>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-03 12:00:00</th>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-05-04 00:00:00</th>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Values\n",
       "Simulation Time            \n",
       "2020-05-01 00:00:00     0.0\n",
       "2020-05-02 00:00:00     1.0\n",
       "2020-05-03 00:00:00     2.0\n",
       "2020-05-03 12:00:00     NaN\n",
       "2020-05-04 00:00:00     3.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doc.c.ts.df.points(\"gap_example\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2021-02-12T17:09:07.868Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax1 = plt.subplots(1, figsize=(8,4))\n",
    "\n",
    "\n",
    "doc.c.hist.df.HEAD.myObsPoint1.plot(ax=ax1, label=\"Observation Point 1\")\n",
    "doc.c.hist.df.HEAD.myObsPoint2.plot(ax=ax1, label=\"Observation Point 2\")\n",
    "\n",
    "ax1b = ax1.twinx()\n",
    "doc.c.ts.df.points(\"well B\").Values.plot(style=\".-\", ax=ax1b, label=\"TimeSeries Pumping Rate\", color=\"red\")\n",
    "ax1.grid()\n",
    "ax1.legend()\n",
    "ax1b.legend(loc=\"upper right\")\n",
    "\n",
    "ax1.set_xlabel(\"\")\n",
    "ax1.set_ylabel(\"Hydraulic head [masl]\")\n",
    "ax1b.set_ylabel(u\"Dewatering Rate [m³/d]\")\n",
    "\n",
    "ax1b.set_ylim(0, 4)\n",
    "\n",
    "plt.savefig(\"highlight_timeseries.png\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2021-02-12T17:09:07.875Z"
    }
   },
   "outputs": [],
   "source": [
    "doc.c.ts.df.points(\"well B\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Observations\n",
    "\n",
    "**Getting a list of observations points**\n",
    "\n",
    "`doc.c.obs.gdf.obspoints` returns the list of obs points as a GeoDataFrame (There is no implementation for Pandas yet - work in progress)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2021-02-12T17:09:08.950Z"
    }
   },
   "outputs": [],
   "source": [
    "doc.c.obs.gdf.obspoints()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting\n",
    "\n",
    "While the GUI can render excellent figures from its various views, there is no documented automation option to export figures e.g. in a batch process. Also - in particular when working with Jupyter Notebooks, an in-line visualization is a very usefull feature to visualize results.\n",
    "\n",
    "A plotting feature has therefore been implemented in *ifm_contrib* that generates matplotlib figure for inline visualization or file output. \n",
    "\n",
    "The implementation roughly follows the rationale of the *View Components* panel, where different styles are put on top of each other. ifm_contrib also implements all of FEFLOWs defaults color schemes and makes them available in the matplotlib upon import.\n",
    "\n",
    "An example is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2021-02-12T17:09:10.008Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "fig, ax1 = plt.subplots(1, figsize = (12, 8))\n",
    "\n",
    "doc.c.plot.faces()\n",
    "doc.c.plot.obs_labels(size=13)\n",
    "doc.c.plot.obs_markers(color=\"red\", alpha=1.)\n",
    "doc.c.plot.fringes(par=ifm.Enum.P_HEAD)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "currently, the following styles are implemented:\n",
    "\n",
    "**Geometry**\n",
    "+ `doc.c.plot.faces`\n",
    "+ `doc.c.plot.edges`\n",
    "\n",
    "**Plotting model properties**\n",
    "\n",
    "The following styles are adopted to plot distributed data:\n",
    "\n",
    "+ `doc.c.plot.continuous`\n",
    "+ `doc.c.plot.fringes`\n",
    "+ `doc.c.plot.isolines`\n",
    "+ `doc.c.plot.patches`\n",
    "\n",
    "the following attributes are supported:\n",
    "\n",
    "+ `par`, `expr`, `distr`, `velocity`: choose the property to be plotted. The syntax is identical to the `doc.c.mesh.df.nodes` / `doc.c.mesh.df.elements` functions.\n",
    "+ `slice` / `layer`: select the slice or layer number\n",
    "+ `global_cos=True` : set to `False` to plot in local coordinates\n",
    "+ `species`: select the species to be plotted\n",
    "+ **any other keyword argument will be forwarded to the underlying matplotlib.pyplot.plot() function.** See the matplotlib documentation for further information.\n",
    "  + one of the most important arguments for isolines and fringes is the argument `levels`, that lets you choose the isoline / fringes corresponding to the Iso-Tab in the GUI.\n",
    "\n",
    "\n",
    "**Observation Points**\n",
    "+ `doc.c.plot.obs_labels`\n",
    "+ `doc.c.plot.obs_markers`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**FEFLOW Color Scales**\n",
    "\n",
    "To achieve a FEFLOW GUI look-and-feel, *ifm_contrib* adds the Standard FEFLOW color schemes to the matplotlib pallet. The following command shows all available colorscales that *ifm_contrib* registers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2021-02-12T17:09:12.156Z"
    }
   },
   "outputs": [],
   "source": [
    "ifm.colormaps.plot_feflow_colorgradients()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because the plotting methods forward any keywords to the plotting functions of the matplotlib, the `cmap` attribute can be used for using a different color scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2021-02-12T17:09:13.215Z"
    }
   },
   "outputs": [],
   "source": [
    "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize = (12, 12))\n",
    "for ax, cmap in [(ax1, \"feflow_rainbow\"),\n",
    "                 (ax2, \"feflow_classic\"),\n",
    "                 (ax3, \"feflow_black_green\"),\n",
    "                 (ax4, \"feflow_blue_green_yellow_red\")]:\n",
    "    plt.sca(ax)\n",
    "    doc.c.plot.faces()\n",
    "    doc.c.plot.fringes(par=ifm.Enum.P_HEAD, cmap=cmap)\n",
    "    plt.title(cmap)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exporting Plots to Shapefiles\n",
    "\n",
    "Isolines and Fringes can be exported to shapefile. This is done by calling the functions\n",
    "\n",
    "+ `doc.c.plot.gdf.fringes()`\n",
    "+ `doc.c.plot.gdf.isolines()`\n",
    "\n",
    "These functions return a GeoDataFrame, that can then be exported to a shape file easily."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2021-02-12T17:09:14.343Z"
    }
   },
   "outputs": [],
   "source": [
    "gdf = doc.c.plot.gdf.isolines(par=ifm.Enum.P_HEAD, levels=[1,3,5,7,9])\n",
    "\n",
    "# geopandas requires that attribute headers are converted to strings\n",
    "gdf.columns = [str(c) for c in gdf.columns]\n",
    "\n",
    "gdf.to_file(\"isolines.shp\")\n",
    "gdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Coordinate Systems**\n",
    "\n",
    "Because FEFLOW models are CRS-naive at this time of writing, geodataframes are by default not georefernenced (and if being saved to a shp-file, no .prj file is written.\n",
    "\n",
    "If assigning the `doc.c.crs` parameter (`None` by default), *ifm_contrib* functions will become CRS-aware and any GeoDataFrames it does export will have a projection to it. Note that this will not be saved with the FEFLOW model, thus it needs to be reassigned everytime after loading the model in ifm_contrib.\n",
    "\n",
    "The CRS must be given as a `pyproj.crs.crs.CRS` object, which can be easily retrieved from an existing shp-file that is CRS-aware:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2021-02-12T17:09:15.435Z"
    }
   },
   "outputs": [],
   "source": [
    "# load an existing file with georeference\n",
    "import geopandas as gpd\n",
    "gdf_file = gpd.read_file(\"./sample-shape.shp\")\n",
    "\n",
    "# assign to ifm_contrib\n",
    "doc.c.crs = gdf_file.crs\n",
    "doc.c.crs"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "py36_dhi",
   "language": "python",
   "name": "py36_dhi"
  },
  "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.10"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}