Repository: EnergyAssetOptimization/EAO (language: python)

Issue:
clean up dev



Discussion / hints:

Fix patch:
diff --git a/doc/source/samples.rst b/doc/source/samples.rst
index 15442fd..98d7b58 100644
--- a/doc/source/samples.rst
+++ b/doc/source/samples.rst
@@ -63,3 +63,10 @@ Split optimization
 
 
 
+Parameter handling
+------------------
+
+.. toctree:: 
+
+   samples/parameter_management/parameter_management
+
diff --git a/doc/source/samples/parameter_management/parameter_management.ipynb b/doc/source/samples/parameter_management/parameter_management.ipynb
new file mode 100644
index 0000000..8b1c9a4
--- /dev/null
+++ b/doc/source/samples/parameter_management/parameter_management.ipynb
@@ -0,0 +1,546 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parameter management\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Some prerequisites & basic definitions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import datetime as dt\n",
+    "pd.set_option(\"mode.chained_assignment\", None) \n",
+    "# in case eao is not installed\n",
+    "import os\n",
+    "import sys\n",
+    "# in case eao is not installed, set path\n",
+    "myDir = os.path.join(os.getcwd(), '../..')\n",
+    "sys.path.append(myDir)\n",
+    "addDir = os.path.join(os.getcwd(), '../../../..')\n",
+    "sys.path.append(addDir)\n",
+    "\n",
+    "import eaopack as eao\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load sample portfolio (and the timegrid)\n",
+    "The portfolio comes prefefined in a JSON. Let us have a look. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "timegrid = eao.serialization.load_from_json(file_name='timegrid.json')\n",
+    "portf    = eao.serialization.load_from_json(file_name='portfolio_simple_start.json')\n",
+    "eao.network_graphs.create_graph(portf)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see. the portfolio is a simple setup with a sourcing possibility and two sales contracts at two locations. For flexibility there is a storage (which we will manipulate in the following)\n",
+    "\n",
+    "## Looking at parameters and setting them to new values\n",
+    "As the next step we look at the parameters that define the portfolio. To this end, EAO provides three routines:\n",
+    "* eao.io.get_params_tree   - to retrieve parameters as a dict and the paths to the parameters. To be used mainly with assets & portfolios\n",
+    "* get_param                - to get parameter values using the path\n",
+    "* set_param                - to change the parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "__class__\n",
+      "['assets', 0, '__class__']\n",
+      "['assets', 0, 'asset_type']\n",
+      "['assets', 0, 'end']\n",
+      "['assets', 0, 'extra_costs']\n",
+      "['assets', 0, 'freq']\n",
+      "['assets', 0, 'max_cap']\n",
+      "['assets', 0, 'min_cap']\n",
+      "['assets', 0, 'name']\n",
+      "['assets', 0, 'nodes', 0, '__class__']\n",
+      "['assets', 0, 'nodes', 0, 'commodity']\n",
+      "['assets', 0, 'nodes', 0, 'name']\n",
+      "['assets', 0, 'nodes', 0, 'unit', '__class__']\n",
+      "['assets', 0, 'nodes', 0, 'unit', 'factor']\n",
+      "['assets', 0, 'nodes', 0, 'unit', 'flow']\n",
+      "['assets', 0, 'nodes', 0, 'unit', 'volume']\n",
+      "['assets', 0, 'periodicity']\n",
+      "['assets', 0, 'periodicity_duration']\n",
+      "['assets', 0, 'price']\n",
+      "['assets', 0, 'profile']\n",
+      "['assets', 0, 'start']\n",
+      "['assets', 0, 'wacc']\n",
+      "['assets', 1, '__class__']\n",
+      "['assets', 1, 'asset_type']\n",
+      "['assets', 1, 'end']\n",
+      "['assets', 1, 'extra_costs']\n",
+      "['assets', 1, 'freq']\n",
+      "['assets', 1, 'max_cap']\n",
+      "['assets', 1, 'min_cap']\n",
+      "['assets', 1, 'name']\n",
+      "['assets', 1, 'nodes', 0, '__class__']\n",
+      "['assets', 1, 'nodes', 0, 'commodity']\n",
+      "['assets', 1, 'nodes', 0, 'name']\n",
+      "['assets', 1, 'nodes', 0, 'unit', '__class__']\n",
+      "['assets', 1, 'nodes', 0, 'unit', 'factor']\n",
+      "['assets', 1, 'nodes', 0, 'unit', 'flow']\n",
+      "['assets', 1, 'nodes', 0, 'unit', 'volume']\n",
+      "['assets', 1, 'periodicity']\n",
+      "['assets', 1, 'periodicity_duration']\n",
+      "['assets', 1, 'price']\n",
+      "['assets', 1, 'profile']\n",
+      "['assets', 1, 'start']\n",
+      "['assets', 1, 'wacc']\n",
+      "['assets', 2, '__class__']\n",
+      "['assets', 2, 'asset_type']\n",
+      "['assets', 2, 'end']\n",
+      "['assets', 2, 'extra_costs']\n",
+      "['assets', 2, 'freq']\n",
+      "['assets', 2, 'max_cap']\n",
+      "['assets', 2, 'min_cap']\n",
+      "['assets', 2, 'name']\n",
+      "['assets', 2, 'nodes', 0, '__class__']\n",
+      "['assets', 2, 'nodes', 0, 'commodity']\n",
+      "['assets', 2, 'nodes', 0, 'name']\n",
+      "['assets', 2, 'nodes', 0, 'unit', '__class__']\n",
+      "['assets', 2, 'nodes', 0, 'unit', 'factor']\n",
+      "['assets', 2, 'nodes', 0, 'unit', 'flow']\n",
+      "['assets', 2, 'nodes', 0, 'unit', 'volume']\n",
+      "['assets', 2, 'periodicity']\n",
+      "['assets', 2, 'periodicity_duration']\n",
+      "['assets', 2, 'price']\n",
+      "['assets', 2, 'profile']\n",
+      "['assets', 2, 'start']\n",
+      "['assets', 2, 'wacc']\n",
+      "['assets', 3, '__class__']\n",
+      "['assets', 3, 'asset_type']\n",
+      "['assets', 3, 'costs_const']\n",
+      "['assets', 3, 'costs_time_series']\n",
+      "['assets', 3, 'efficiency']\n",
+      "['assets', 3, 'end']\n",
+      "['assets', 3, 'freq']\n",
+      "['assets', 3, 'max_cap']\n",
+      "['assets', 3, 'min_cap']\n",
+      "['assets', 3, 'name']\n",
+      "['assets', 3, 'nodes', 0, '__class__']\n",
+      "['assets', 3, 'nodes', 0, 'commodity']\n",
+      "['assets', 3, 'nodes', 0, 'name']\n",
+      "['assets', 3, 'nodes', 0, 'unit', '__class__']\n",
+      "['assets', 3, 'nodes', 0, 'unit', 'factor']\n",
+      "['assets', 3, 'nodes', 0, 'unit', 'flow']\n",
+      "['assets', 3, 'nodes', 0, 'unit', 'volume']\n",
+      "['assets', 3, 'nodes', 1, '__class__']\n",
+      "['assets', 3, 'nodes', 1, 'commodity']\n",
+      "['assets', 3, 'nodes', 1, 'name']\n",
+      "['assets', 3, 'nodes', 1, 'unit', '__class__']\n",
+      "['assets', 3, 'nodes', 1, 'unit', 'factor']\n",
+      "['assets', 3, 'nodes', 1, 'unit', 'flow']\n",
+      "['assets', 3, 'nodes', 1, 'unit', 'volume']\n",
+      "['assets', 3, 'periodicity']\n",
+      "['assets', 3, 'periodicity_duration']\n",
+      "['assets', 3, 'profile']\n",
+      "['assets', 3, 'start']\n",
+      "['assets', 3, 'wacc']\n",
+      "['assets', 4, '__class__']\n",
+      "['assets', 4, 'asset_type']\n",
+      "['assets', 4, 'block_size']\n",
+      "['assets', 4, 'cap_in']\n",
+      "['assets', 4, 'cap_out']\n",
+      "['assets', 4, 'cost_in']\n",
+      "['assets', 4, 'cost_out']\n",
+      "['assets', 4, 'cost_store']\n",
+      "['assets', 4, 'eff_in']\n",
+      "['assets', 4, 'end']\n",
+      "['assets', 4, 'end_level']\n",
+      "['assets', 4, 'freq']\n",
+      "['assets', 4, 'inflow']\n",
+      "['assets', 4, 'max_store_duration']\n",
+      "['assets', 4, 'name']\n",
+      "['assets', 4, 'no_simult_in_out']\n",
+      "['assets', 4, 'nodes', 0, '__class__']\n",
+      "['assets', 4, 'nodes', 0, 'commodity']\n",
+      "['assets', 4, 'nodes', 0, 'name']\n",
+      "['assets', 4, 'nodes', 0, 'unit', '__class__']\n",
+      "['assets', 4, 'nodes', 0, 'unit', 'factor']\n",
+      "['assets', 4, 'nodes', 0, 'unit', 'flow']\n",
+      "['assets', 4, 'nodes', 0, 'unit', 'volume']\n",
+      "['assets', 4, 'periodicity']\n",
+      "['assets', 4, 'periodicity_duration']\n",
+      "['assets', 4, 'price']\n",
+      "['assets', 4, 'profile']\n",
+      "['assets', 4, 'size']\n",
+      "['assets', 4, 'start']\n",
+      "['assets', 4, 'start_level']\n",
+      "['assets', 4, 'wacc']\n"
+     ]
+    }
+   ],
+   "source": [
+    "[params, param_dict] = eao.io.get_params_tree(portf)\n",
+    "for p in params:\n",
+    "    print(p)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Looking at the parameter tree, note that we extracted the whole tree of parameters in the portfolio. Each entry is a list, that points downwards into the nested object (portfolio --> asset, --> ...)\n",
+    "\n",
+    "To access the parameter, we can use any of those entries. Let us concentrate on the storage (asset no. 4):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'__class__': 'Asset',\n",
+       " 'asset_type': 'Storage',\n",
+       " 'block_size': None,\n",
+       " 'cap_in': 30,\n",
+       " 'cap_out': 30,\n",
+       " 'cost_in': 0.2,\n",
+       " 'cost_out': 0.2,\n",
+       " 'cost_store': 0.0,\n",
+       " 'eff_in': 1.0,\n",
+       " 'end': None,\n",
+       " 'end_level': 5,\n",
+       " 'freq': None,\n",
+       " 'inflow': 0.0,\n",
+       " 'max_store_duration': None,\n",
+       " 'name': 'storage',\n",
+       " 'no_simult_in_out': False,\n",
+       " 'nodes': [{'__class__': 'Node',\n",
+       "   'commodity': None,\n",
+       "   'name': 'location b',\n",
+       "   'unit': {'__class__': 'Unit',\n",
+       "    'factor': 1.0,\n",
+       "    'flow': 'MW',\n",
+       "    'volume': 'MWh'}}],\n",
+       " 'periodicity': None,\n",
+       " 'periodicity_duration': None,\n",
+       " 'price': None,\n",
+       " 'profile': None,\n",
+       " 'size': 48,\n",
+       " 'start': None,\n",
+       " 'start_level': 5,\n",
+       " 'wacc': 0.0}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "param_dict['assets'][4]\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, get direct access via tree entries, e.g. the fill level on start up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(eao.io.get_param(portf, ['assets', 4, 'start_level']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Going via the complete portfolio is one way. However, it is also possible to directly go via specific assets:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "price sales b\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(eao.io.get_param(portf.get_asset('sales b'), ['price']))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us manipulate the fill level. Note that this could also be done by diving directly into the object ..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n"
+     ]
+    }
+   ],
+   "source": [
+    "portf.get_asset('storage').start_level = 4\n",
+    "print(portf.get_asset('storage').start_level)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "... but setting parameters this way is actually relatively insecure, since this corcumvents proper initialization. Therefore, it is better to use the set_garam routine:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6\n"
+     ]
+    }
+   ],
+   "source": [
+    "portf = eao.io.set_param(portf,['assets', 4, 'start_level'], 6 )\n",
+    "print(portf.get_asset('storage').start_level)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This routine properly extracts parameters using the serialization machinery and re-initiates the objects. Therefore, all tests are called.\n",
+    "\n",
+    "Let us take a look by setting an invalid parameter. In this case we set the storage size to a value which is smaller than the initial fill level:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Not possible\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    portf = eao.io.set_param(portf, ['assets', 4, 'size'], 1.)\n",
+    "except Exception as error:\n",
+    "    print('Not possible')\n",
+    "    pass\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Sample: Looping different parameters\n",
+    "\n",
+    "Here we do a simple loop on the storage size to demonstrate how to manipulate parameters for parameter studies or how to react to live data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# sample prices\n",
+    "prices = {'price sourcing': 5.*np.sin(np.linspace(0.,6., timegrid.T)),\n",
+    "         'price sales a' : np.ones(timegrid.T)*2.,\n",
+    "         'price sales b' : 5.+5.*np.sin(np.linspace(0.,6., timegrid.T))  }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Current storage size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "48\n",
+      "MWh\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(eao.io.get_param(portf, ['assets', 4, 'size']))\n",
+    "print(eao.io.get_param(portf, ['assets', 4, 'nodes', 0,'unit','volume']))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "storage_sizes = range(10, 150, 5)\n",
+    "values = [] # collect results\n",
+    "\n",
+    "for my_size in storage_sizes:\n",
+    "    portf = eao.io.set_param(portf, ['assets', 4, 'size'], my_size )\n",
+    "    optim_problem  = portf.setup_optim_problem(timegrid = timegrid, prices=prices)\n",
+    "    result         = optim_problem.optimize()\n",
+    "    values.append(result.value)\n",
+    "# output = eao.io.extract_output(portf, optim_problem, result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure(figsize = (12,3))\n",
+    "plt.bar(storage_sizes, values, width = 4)\n",
+    "plt.ylim((6000, 7000))\n",
+    "plt.xlabel('storage size')\n",
+    "plt.ylabel('total portfolio value')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is just for demonstration purpose. However - neat to see how the value add of extra storage size decreases."
+   ]
+  }
+ ],
+ "metadata": {
+  "hide_input": false,
+  "kernelspec": {
+   "display_name": "new_versions",
+   "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.11.4"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/doc/source/samples/parameter_management/portfolio_simple_start.json b/doc/source/samples/parameter_management/portfolio_simple_start.json
new file mode 100644
index 0000000..2172763
--- /dev/null
+++ b/doc/source/samples/parameter_management/portfolio_simple_start.json
@@ -0,0 +1,149 @@
+{
+    "__class__": "Portfolio",
+    "assets": [
+        {
+            "__class__": "Asset",
+            "asset_type": "SimpleContract",
+            "end": null,
+            "extra_costs": 0.0,
+            "max_cap": 50.0,
+            "min_cap": 0.0,
+            "name": "sourcing",
+            "nodes": [
+                {
+                    "__class__": "Node",
+                    "commodity": null,
+                    "name": "location a",
+                    "unit": {
+                        "__class__": "Unit",
+                        "factor": 1.0,
+                        "flow": "MW",
+                        "volume": "MWh"
+                    }
+                }
+            ],
+            "price": "price sourcing",
+            "start": null,
+            "wacc": 0
+        },
+        {
+            "__class__": "Asset",
+            "asset_type": "SimpleContract",
+            "end": null,
+            "extra_costs": 0.0,
+            "max_cap": -5.0,
+            "min_cap": -10.0,
+            "name": "sales a",
+            "nodes": [
+                {
+                    "__class__": "Node",
+                    "commodity": null,
+                    "name": "location a",
+                    "unit": {
+                        "__class__": "Unit",
+                        "factor": 1.0,
+                        "flow": "MW",
+                        "volume": "MWh"
+                    }
+                }
+            ],
+            "price": "price sales a",
+            "start": null,
+            "wacc": 0
+        },
+        {
+            "__class__": "Asset",
+            "asset_type": "SimpleContract",
+            "end": null,
+            "extra_costs": 1.0,
+            "max_cap":  0.0,
+            "min_cap": -2.0,
+            "name": "sales b",
+            "nodes": [
+                {
+                    "__class__": "Node",
+                    "commodity": null,
+                    "name": "location b",
+                    "unit": {
+                        "__class__": "Unit",
+                        "factor": 1.0,
+                        "flow": "MW",
+                        "volume": "MWh"
+                    }
+                }
+            ],
+            "price": "price sales b",
+            "start": null,
+            "wacc": 0
+        },
+        {
+            "__class__": "Asset",
+            "asset_type": "Transport",
+            "costs_const": 1.0,
+            "costs_time_series": null,
+            "efficiency": 1.0,
+            "start": null,
+            "end": null,
+            "max_cap": 5.0,
+            "min_cap": 0.0,
+            "name": "grid",
+            "nodes": [
+                {
+                    "__class__": "Node",
+                    "commodity": null,
+                    "name": "location a",
+                    "unit": {
+                        "__class__": "Unit",
+                        "factor": 1.0,
+                        "flow": "MW",
+                        "volume": "MWh"
+                    }
+                },
+                {
+                    "__class__": "Node",
+                    "commodity": null,
+                    "name": "location b",
+                    "unit": {
+                        "__class__": "Unit",
+                        "factor": 1.0,
+                        "flow": "MW",
+                        "volume": "MWh"
+                    }
+                }
+            ],
+            "wacc": 0
+        },
+        {
+            "__class__": "Asset",
+            "asset_type": "Storage",
+            "block_size": null,
+            "start_level": 5,
+            "cap_in": 30,
+            "cap_out": 30,
+            "cost_in": 0.2,
+            "cost_out": 0.2,
+            "eff_in": 1.0,
+            "size": 48,
+            "start": null,
+            "end": null,
+            "end_level": 5,
+            "inflow": 0.0,
+            "name": "storage",
+            "nodes": [
+                {
+                    "__class__": "Node",
+                    "commodity": null,
+                    "name": "location b",
+                    "unit": {
+                        "__class__": "Unit",
+                        "factor": 1.0,
+                        "flow": "MW",
+                        "volume": "MWh"
+                    }
+                }
+            ],
+            "price": null,
+            "wacc": 0.0
+        }
+    ]
+}
\ No newline at end of file
diff --git a/doc/source/samples/parameter_management/timegrid.json b/doc/source/samples/parameter_management/timegrid.json
new file mode 100644
index 0000000..2805d38
--- /dev/null
+++ b/doc/source/samples/parameter_management/timegrid.json
@@ -0,0 +1,13 @@
+{
+    "__class__": "Timegrid",
+    "start": {
+        "__class__": "date",
+        "__value__": "2021-01-01"
+    },
+    "end": {
+        "__class__": "date",
+        "__value__": "2021-01-10"
+    },
+    "freq": "h",
+    "main_time_unit": "h"
+}
\ No newline at end of file
diff --git a/eaopack/assets.py b/eaopack/assets.py
index a0acf1e..4a7f58f 100644
--- a/eaopack/assets.py
+++ b/eaopack/assets.py
@@ -54,6 +54,7 @@ def __init__(self,
             self.profile = profile
             if profile is not None:
                 assert isinstance(profile, pd.Series), 'Profile must be np.Series. Asset:'+str(name)
+
     def set_timegrid(self, timegrid: Timegrid):
         """ Set the timegrid for the asset
         Args:
@@ -180,6 +181,8 @@ def convert_to_timegrid_freq(self, time_value: float, attribute_name: str, old_f
             time_value_converted = int(time_value_converted)
         return time_value_converted
 
+
+
 ##########################
 
 class Storage(Asset):
diff --git a/eaopack/io.py b/eaopack/io.py
index cf9792a..37e8d90 100644
--- a/eaopack/io.py
+++ b/eaopack/io.py
@@ -1,9 +1,11 @@
 import numpy as np
 import pandas as pd
 import datetime as dt
+import copy
 
 from eaopack.portfolio import Portfolio
 from eaopack.optimization import Results, OptimProblem
+from eaopack import serialization 
 
 
 def extract_output(portf: Portfolio, op: OptimProblem, res:Results, prices: dict = None) -> dict:
@@ -126,7 +128,6 @@ def extract_output(portf: Portfolio, op: OptimProblem, res:Results, prices: dict
 
     return output
 
-
 def output_to_file(output, file_name:str, format_output:str = 'xlsx',csv_ger:bool = False):
     """ write extracted output to file(s)
 
@@ -161,3 +162,92 @@ def output_to_file(output, file_name:str, format_output:str = 'xlsx',csv_ger:boo
             output[myk].to_csv(myk+'_'+file_name, sep = sep, decimal = decimal)                
     else:
         raise NotImplementedError('output format - '+format_output+' - not implemented')
+
+#### easy access to object parameters e.g. for assets & portfolio
+## get tree, get parameter, set parameter
+def get_params_tree(obj) -> (list, dict):
+    """ get parameters of object - typically asset or portfolio
+
+    Args:
+        obj (object): object to analyze
+    Returns 
+        dict of parameters (nested)
+        list of parameter names (nested)
+    """
+
+    def make_dict(dd) -> (list, dict):
+        if isinstance(dd, list): dd_keys = range(0,len(dd))
+        elif isinstance(dd, dict): dd_keys = list(dd)
+        else: 
+            return None, None
+        keys = [] # record keys
+        for k in dd_keys:
+            if isinstance(dd[k], dict) or isinstance(dd[k], list): 
+                if isinstance(dd[k], list): ks = range(0,len(dd[k]))
+                if isinstance(dd[k], dict): ks = list(dd[k])
+                for myk in ks:
+                    if not isinstance(myk, list): l_myk = [myk]
+                    else: l_myk = myk
+                    if isinstance(dd[k][myk], dict) or isinstance(dd[k][myk], list):
+                        _ , tk = make_dict(dd[k][myk])
+                        for ttk in tk:
+                            if not isinstance(ttk, list): l_ttk = [ttk]
+                            else: l_ttk = ttk
+                            keys.append([k] + l_myk + l_ttk)
+                    else: keys.append([k] + l_myk)
+            else: keys.append(k)
+
+        return copy.deepcopy(dd), keys
+        
+    # serialize and back to get rid of superfluous parameters (not set during __init__)
+    s = serialization.to_json(obj) # serialize using all specific definitions
+    dd = serialization.json.loads(s) # create simple dict
+    o, k = make_dict(dd)
+    return k, o
+
+def get_param(obj, path):
+    """ get specific parameter from an object using the path as generated from get_params_tree
+
+    Args:
+        path (_type_): list down to parameter as given by get_params_tree (e.g. [asset, timegrid, start] --> value)
+    """
+    def get(d,l):
+        """ recursion to access nested dict """
+        if len(l) == 1: return d[l[0]]
+        return get(d[l[0]], l[1:])
+    
+    k,o = get_params_tree(obj)
+    if not isinstance(path, list): path = [path]
+    return get(o, path)
+    
+
+def set_param(obj, path, value):
+    """ Set parameters of EAO objects. Limited checks, but facilitating managing nested objects such as portfolios or assets
+
+    Args:
+        obj (object): Object to manipulate
+
+    Returns:
+        obj (object): Manipulated object
+        status (bool): True - > successful, False -> not successful
+    """
+    def sett(o,l,v):
+        """ recursion to access nested object """
+        if len(l) == 1: # leaf in tree. Set value
+            o[l[0]] = v
+            return o
+        return sett(o[l[0]], l[1:], v) # recursion. Go down path
+    
+    if not isinstance(path, list): path = [path]
+    k,o = get_params_tree(obj)
+    _ = sett(o, path, value) # manipulates dict. output not needed
+    
+    try:
+        s = serialization.json.dumps(o)
+        res = serialization.load_from_json(s) # create object again (properly initializing)
+    except:
+        if 'name' in o: n = o['name']
+        else: n = 'NA'
+        raise ValueError('Error. Object could not be created. Parameter issue? Object: '+n+' | parameter '+str(path))
+    return res
+
diff --git a/eaopack/requirements.txt b/eaopack/requirements.txt
index be556e0..869a1fb 100644
--- a/eaopack/requirements.txt
+++ b/eaopack/requirements.txt
@@ -3,4 +3,6 @@ pandas
 datetime
 cvxpy >= 1.17
 scipy >= 1.5.4
-json
\ No newline at end of file
+json
+networkx
+matplotlib
\ No newline at end of file
diff --git a/eaopack/serialization.py b/eaopack/serialization.py
index f2e4917..4517c06 100644
--- a/eaopack/serialization.py
+++ b/eaopack/serialization.py
@@ -48,6 +48,7 @@ def json_serialize_objects(obj) -> dict:
                }
     elif isinstance(obj, Asset):
         res = obj.__dict__.copy()
+        res.pop('timegrid',None)
         res.pop('asset_names',None)
         res.pop('start_ramp_time', None)  # only relevant for class CHPAsset, calculated
         res.pop('shutdown_ramp_time', None)  # only relevant for class CHPAsset, calculated
diff --git a/setup.cfg b/setup.cfg
index b56456f..add1782 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,6 +1,6 @@
 [metadata]
 name = eaopack
-version = 1.2.9
+version = 1.3.0
 author = The EAO development Team
 description = A Framework for Optimizing Decentralized Portfolios and Green Supply
 long_description = file: README.md


Test patch:
diff --git a/tests/test_setting_params.py b/tests/test_setting_params.py
new file mode 100644
index 0000000..8ec27e7
--- /dev/null
+++ b/tests/test_setting_params.py
@@ -0,0 +1,81 @@
+import numpy as np
+from numpy.core.shape_base import block
+import pandas as pd
+import datetime as dt
+import json
+
+import unittest   
+
+from os.path import dirname, join
+import os
+import sys
+mypath = (dirname(__file__))
+sys.path.append(join(mypath, '..'))
+
+import eaopack as eao
+
+class test_setting_params(unittest.TestCase):
+
+    def test_getting_and_setting_parameters(self):
+        """ Unit test. Setting up a simple contract with random prices 
+            and check that it buys full load at negative prices and opposite
+        """
+
+        ### define asset and get parameters
+        node = eao.assets.Node('testNode')
+        timegrid = eao.assets.Timegrid(dt.date(2021,1,1), dt.date(2021,2,1), freq = 'd')
+        a = eao.assets.SimpleContract(name = 'SC', price = 'rand_price', nodes = node ,
+                        min_cap= -10., max_cap=10., extra_costs=10, start = dt.date(2021,2,1))
+        
+        # to test: the timegrid is no parameter of the asset! This should get lost in the process
+        a.set_timegrid(timegrid)
+        # get parameter tree
+        k,d = eao.io.get_params_tree(a)
+        # d is a dictionary of all parameters (nested)
+        # k is a list of parameter names (pointing downwards into nested objects)
+        self.assertEqual(len(d), 15)
+        self.assertEqual(len(k), 22)
+        ### get parameter
+        self.assertEqual(eao.io.get_param(a, 'name'), 'SC')
+        self.assertEqual(eao.io.get_param(a,['nodes', 0, 'unit', 'volume']), 'MWh')
+        ### set parameter
+        a = eao.io.set_param(a, ['name'], 'test')
+        self.assertEqual(a.name, 'test')
+        a = eao.io.set_param(a, ['start', '__value__'], '2021-01-01')
+        self.assertEqual(a.start, dt.date(2021,1,1))
+        a = eao.io.set_param(a,['nodes', 0, 'unit', 'volume'], 'kWh')
+        self.assertEqual(eao.io.get_param(a,['nodes', 0, 'unit', 'volume']), 'kWh')
+
+    def test_setting_portfolio(self):
+        node1 = eao.assets.Node('node_1')
+        node2 = eao.assets.Node('node_2')
+        node3 = eao.assets.Node('node_3')
+        a1 = eao.assets.SimpleContract(name = 'SC_1', price = 'rand_price_1', nodes = node1 ,
+                        min_cap= -20., max_cap=-5., start = dt.date(2021,1,10), end = dt.date(2021,1,20))
+        a1a = eao.assets.SimpleContract(name = 'SC_1a', price = 'rand_price_1', nodes = node3 ,
+                        min_cap= -20., max_cap= 20., start = dt.date(2021,1,10), end = dt.date(2021,1,20))
+
+        #a1.set_timegrid(timegrid)
+        a2 = eao.assets.SimpleContract(name = 'SC_2', price = 'rand_price_1', nodes = node1 ,
+                        min_cap= -15., max_cap=-10.)#, extra_costs= 1.)
+        #a2.set_timegrid(timegrid)
+        a3 = eao.assets.SimpleContract(name = 'SC_3', price = 'rand_price_2', nodes = node2 ,
+                        min_cap= 0., max_cap=100., extra_costs= 1.)
+        a4 = eao.assets.Transport(name = 'Tr', costs_const= 5., nodes = [node2, node1],
+                        min_cap= 0., max_cap=100.)
+
+        portf = eao.portfolio.Portfolio([a1, a2, a3, a4,a1a])
+        k,d = eao.io.get_params_tree(portf)
+        p = eao.io.set_param(portf, ['assets', 0, 'nodes', 0, 'unit', 'flow'], 'kW')
+        eao.io.get_param(portf, ['assets', 0, 'nodes', 0, 'unit', 'flow'])
+        # original unchanged
+        self.assertEqual(eao.io.get_param(portf, ['assets', 0, 'nodes', 0, 'unit', 'flow']), 'MW')
+        # new changed
+        self.assertEqual(eao.io.get_param(p, ['assets', 0, 'nodes', 0, 'unit', 'flow']), 'kW')
+        # new changed
+        pass
+
+
+if __name__ == "__main__" :
+    unittest.main()
+