Repository: EnergyAssetOptimization/EAO (language: python)

Issue:
action script updated



Discussion / hints:

Fix patch:
diff --git a/doc/source/samples.rst b/doc/source/samples.rst
index 98d7b58..a03a866 100644
--- a/doc/source/samples.rst
+++ b/doc/source/samples.rst
@@ -30,12 +30,12 @@ Combined Heat and Power
 
    samples/combined_heat_power/chp_sample
 
-Efficient optimization across different time scales
+Optimization against a discrete order book
 ---------------------------------------------------
 
 .. toctree:: 
 
-   samples/mixing_long_and_short_term/mixing_long_and_short_term.ipynb
+   samples/order_book/order_book_battery.ipynb
 
 
 Stochastic Linear Programs
@@ -61,6 +61,13 @@ Split optimization
 
    samples/split_optimization/split_optimization
 
+Special case: order books
+------------------
+
+.. toctree:: 
+
+   samples/split_optimization/order_book
+
 
 
 Parameter handling
diff --git a/doc/source/samples/order_book/order_book_battery.ipynb b/doc/source/samples/order_book/order_book_battery.ipynb
new file mode 100644
index 0000000..9e2798f
--- /dev/null
+++ b/doc/source/samples/order_book/order_book_battery.ipynb
@@ -0,0 +1,317 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Discrete supply decisions - example battery in continuous intraday markets\n",
+    "\n",
+    "We often face discrete execution decisions in energy. Those may be shippings (e.g. LNG) or order books in futures markets. Another example are continuous intraday power or gas markets.  Let us focus on the latter in this example of optimizing a battery directly against an intraday power order book.\n",
+    "\n",
+    "Our example: The main market targeted by battery storage (besides reserve markets) is the power intraday market. When power prices are low, the battery is charged, to be discharded at higher power prices. When optimizing a battery against the intraday market, a typical simplification is to assume there is a price for each time interval (such as 15min in central Europe). Following this optimization, we pass the position to our autotrader, that targets to close the position at the assumed price curve (or better, naturally). \n",
+    "\n",
+    "This simplification is often good, but does not account for significant features if the market: \n",
+    "* Orders may have to be executed all or nothing. If orders are large as compared to the battery, this cannot be neglected\n",
+    "* Bid ask spread. There may be a significant price gap between buying and selling\n",
+    "* Limited liquidity. We may not be able to trade the full dispatch potential of the battery. Particularly for shallow markets and large assets this may have a significant effect\n",
+    "\n",
+    "Note how we consistently solve for an exact match between battery dispatch and order execution. If a direct link to an autotrader is established, this enables us to do a direct execution. Naturally there are many aspects to be accounted for in real life from this static demo to a live solution with a changing order and position tracker."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Some prerequisites\n",
+    "\n",
+    "Import relevant packages and set links. Note that we set a random seed for the generation of our randomized order book."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import datetime as dt\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\n",
+    "np.random.seed(6924)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Setup (1) Basics \n",
+    "\n",
+    "Defining start, end and time grid. Here we optimize over a full day in an hourly granularity. That's an artificial choice for sake of visual clarity, of course."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "node = eao.assets.Node('power')\n",
+    "S = dt.date(2021,1,1)\n",
+    "E = dt.date(2021,1,2)\n",
+    "timegrid = eao.assets.Timegrid(S, E, freq = 'h') # using hours for better visualization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### (2) Order book\n",
+    "\n",
+    "As the first ingredient we generate a randomized order book with orders of various prices, capacities and duration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create larger number of orders\n",
+    "## some time steps, buy & sell\n",
+    "ob = pd.DataFrame(columns = ['start', 'end', 'capa', 'price']) # alternative to dict is DataFrame ... converted in asset\n",
+    "r = dict() # row\n",
+    "### orders\n",
+    "# orders with bid/ask spread on base signal\n",
+    "# base signal\n",
+    "bs = (30*np.sin(timegrid.I/24*2*np.pi*2)+40).round(0) + 0*np.random.randn(timegrid.T).cumsum()\n",
+    "prices = {'av': bs}\n",
+    "for ii in timegrid.I:\n",
+    "    tp = timegrid.timepoints[ii]\n",
+    "    # sell (they sell)\n",
+    "    for i in range(0,5):\n",
+    "        r['start']   = tp\n",
+    "        r['end']     = tp + pd.Timedelta(np.random.randint(1, 4), 'h')\n",
+    "        r['capa']    = np.random.randint(1, 4)\n",
+    "        r['price']   = bs[ii] + np.random.randint(10, 50)\n",
+    "        ob.loc[len(ob)] = r\n",
+    "    # buy (they buy)\n",
+    "    for i in range(0,5):\n",
+    "        r['start']   = tp\n",
+    "        r['end']     = tp + pd.Timedelta(np.random.randint(1, 4), 'h')\n",
+    "        r['capa']    = -np.random.randint(1, 4)\n",
+    "        r['price']   = bs[ii] + np.random.randint(-10, 10)\n",
+    "        ob.loc[len(ob)] = r            \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The artificial order book shown with their price against time of delivery. The thickness of the orders indicates their sice"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.rcdefaults()\n",
+    "fig, ax = plt.subplots(1,1,figsize=(10,4), tight_layout = True)\n",
+    "#out['dispatch'].loc[:,'battery'].plot(ax = ax)\n",
+    "for i,r in ob.iterrows():\n",
+    "    if r['capa']>0  :  ax.plot([r['start'], r['end']], [r['price'],r['price']],'b-',linewidth = abs(r['capa']), alpha = 0.3)\n",
+    "    elif r['capa']<0:  ax.plot([r['start'], r['end']], [r['price'],r['price']],'r-',linewidth = abs(r['capa']), alpha = 0.3)\n",
+    "ax.set_title('Order book')\n",
+    "ax.set_ylabel('EUR/MWh')\n",
+    "# for legend only\n",
+    "ax.plot([S, S], [0,0],'b-',linewidth = 5, alpha = 0.3, label = 'sell')\n",
+    "ax.plot([S, S], [0,0],'r-',linewidth = 5, alpha = 0.3, label = 'buy')\n",
+    "ax.legend(loc = 'upper right')\n",
+    "ax.set_xlim(S, E)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### (3) Assets\n",
+    "\n",
+    "Order book: We utilize a specific asset in EAO to implement the behaviour of the order book. Note that the asset has a parameter \"full_exec\". Setting it to False, the optimizer is allowed to execute parts of an order -- and the optimization problem is continuous and thus very fast (on my laptop 1.4s). In reality most of the orders will still be executed fully due to the nature of the problem setup. If required, the parameter may be set to True, resulting in a more complex MIP as orders must be executed fully (6.6s).\n",
+    "\n",
+    "Battery: Our main asset is a battery storage. We choose artificial parameters such as 95% efficiency and a size of 40 MWh as compared to a capacity of 10 MW (a 4h battery). Note that we need to specifc a start and a target fill level.\n",
+    "\n",
+    "Target fill level flex: The target fill level requires some additional thoughts. Left unpenalized, an optimizer will completely drain a battery at the end of the day (in case power prices are positive). In order to avoid this we need to define the value battery power has for us towards the end of the day. We do this by forcing the battery to be left at 50% fill level and adding an \"extra source\" for power with a market price above the order book. Power drawn from this \"extra source\" represents battery usage from this 50% target fill level.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# order book asset\n",
+    "order_book = eao.assets.OrderBook('orders', node, \n",
+    "                                    orders    = ob, \n",
+    "                                    full_exec = True)  # switch to enforce (or not) full order execution\n",
+    "\n",
+    "# battery\n",
+    "battery = eao.assets.Storage('battery', node, cap_in      = 10, \n",
+    "                                        cap_out     = 10,\n",
+    "                                        start_level = 20,\n",
+    "                                        end_level   = 20,\n",
+    "                                        eff_in      = 0.95,\n",
+    "                                        size        = 40)\n",
+    "# last resort - battery end level. May allow battery not to be completely full, \"borrowing\" in last hours\n",
+    "extra_power = eao.assets.SimpleContract('fill_level_adjust', node,\n",
+    "                                max_cap   = 10,\n",
+    "                                min_cap   = 0,\n",
+    "                                start     = timegrid.timepoints[-2],\n",
+    "                                end       = E,\n",
+    "                                price     = 'av',\n",
+    "                                extra_costs = 20\n",
+    "                                )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### (4) Setting up the portfolio\n",
+    "\n",
+    "In EAO we can easily link all assets in a portfolio. By refering to the same node we ensure their dispatch sums to zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "portf = eao.portfolio.Portfolio([battery, order_book, extra_power])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Perform the optimization\n",
+    "\n",
+    "Once the portfolio is set up, optimization can be called and the output extracted."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "op = portf.setup_optim_problem(prices=prices, timegrid=timegrid)\n",
+    "res = op.optimize(solver = 'SCIP')\n",
+    "out = eao.io.extract_output(portf= portf, op=op, res=res)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create charts and interpret the results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.rcdefaults()\n",
+    "fig, ax = plt.subplots(1,1,figsize=(10,4), tight_layout = True)\n",
+    "for i,r in ob.iterrows():\n",
+    "    if out['special'].loc[i,'value'] > 0.95: myal = 1\n",
+    "    else: myal = 0.05 # executed\n",
+    "    if   r['capa']>0: ax.plot([r['start'], r['end']], [r['price'],r['price']],'b-',linewidth = abs(r['capa']), alpha = myal)\n",
+    "    elif r['capa']<0: ax.plot([r['start'], r['end']], [r['price'],r['price']],'r-',linewidth = abs(r['capa']), alpha = myal)\n",
+    "ax.set_title('Executed orders')\n",
+    "ax.set_ylabel('prices of orders EUR/MWh')\n",
+    "ax.plot([S, S], [0,0],'b-',linewidth = 5, alpha = 1, label = 'executed sell - we buy')\n",
+    "ax.plot([S, S], [0,0],'r-',linewidth = 5, alpha = 1, label = 'executed buy - we sell')\n",
+    "ax.set_xlim(S, E)\n",
+    "ax2 = ax.twinx() \n",
+    "fill_level = (-out['dispatch'].loc[:,'battery']).cumsum()+20\n",
+    "# fill_level.plot(ax = ax, color = 'k', linestyle = '-', marker = '.', label = 'battery fill level')\n",
+    "ax2.plot(fill_level, label = 'battery fill level')\n",
+    "ax2.set_ylabel('fill level battery in MWh')\n",
+    "ax.legend(loc = 'upper left')\n",
+    "ax2.legend(loc = 'upper right')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In bold color we can observe orders that have been executed. We have successfully combined a battery with a discrete order book consisting of orders that are partly overlapping and come with various prices and sizes."
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "be3a6be14975f865340184f994f156f34e69121a76ba7e4bc9a17cfb93fc79ca"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.9.2 64-bit",
+   "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.12.5"
+  },
+  "orig_nbformat": 2
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/eaopack/assets.py b/eaopack/assets.py
index c833295..f47a3dc 100644
--- a/eaopack/assets.py
+++ b/eaopack/assets.py
@@ -184,7 +184,41 @@ 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
 
+    def make_vector(self, value:  Union[float, StartEndValueDict, str], prices:dict, default_value: float = None, convert=False):
+        """
+        Make a vector out of value
+        Args:
+            value (float, dict, str): The value to be converted to a vector
+                                      float: constant value
+                                      dict:  dict['start'] = array
+                                             dict['end']   = array
+                                             dict['values'] = array
+                                      str:   refers to column in "prices" data that provides time series to set up OptimProblem (as for "price" below)
+            prices (dict): Dictionary of price arrays needed by assets in portfolio
+            default_value (float): The value that is used if any of the entries of the resulting vector are not specified
 
+        Returns: vector in time grid
+
+        """
+        I = self.timegrid.restricted.I  # indices of restricted time grid
+        T = self.timegrid.restricted.T
+        if value is None:
+            return value
+        elif isinstance(value, (float, int, np.ndarray)):
+            vec = value * np.ones(T)
+        elif isinstance(value, str):
+            assert (value in prices), 'data for ' + value + ' not found for asset  ' + self.name
+            vec = prices[value].copy()
+            if isinstance(vec, pd.Series): vec = vec.values # may be given as Series (prices as DataFrame) (not prefered, but sometimes handy)
+            vec = vec[I]  # only in asset time window
+        else:  # given in form of dict (start/end/values)
+            vec = self.timegrid.restricted.values_to_grid(value)
+            if default_value is not None:
+                vec[np.isnan(vec)] = default_value
+
+        if convert:
+            vec = vec * self.timegrid.restricted.dt
+        return vec
 
 ##########################
 
@@ -567,7 +601,7 @@ def __init__(self,
                                             str:   refers to column in "prices" data that provides time series to set up OptimProblem (as for "price" below)
 
             periodicity (str, pd freq style): Makes assets behave periodicly with given frequency. Periods are repeated up to freq intervals (defaults to None)
-            periodicity_duration (str, pd freq style): Intervals in which periods repeat (e.g. repeat days ofer whole weeks)  (defaults to None)
+            periodicity_duration (str, pd freq style): Intervals in which periods repeat (e.g. repeat days over whole weeks)  (defaults to None)
         """
         super(SimpleContract, self).__init__(name=name,
                                              nodes=nodes,
@@ -607,8 +641,8 @@ def setup_optim_problem(self, prices: dict, timegrid:Timegrid = None, costs_only
         # set timegrid if given as optional argument
         if not timegrid is None:
             self.set_timegrid(timegrid)
-        else:
-            timegrid = self.timegrid
+        # else:
+        #     timegrid = self.timegrid
         # check: timegrid set?
         if not hasattr(self, 'timegrid'):
             raise ValueError('Set timegrid of asset before creating optim problem. Asset: '+ self.name)
@@ -684,6 +718,7 @@ def setup_optim_problem(self, prices: dict, timegrid:Timegrid = None, costs_only
             # infos:             'asset', 'node', 'type'
             mapping['time_step'] = np.hstack((I, I))
             mapping['var_name']  = np.nan # name variables for use e.g. in RI
+            mapping['var_name'] = mapping['var_name'].astype(str)
             ind_var_name = mapping.columns.get_indexer(['var_name'])[0]
             # mapping['var_name'].iloc[0:T] = 'disp_in'
             # mapping['var_name'].iloc[T:] = 'disp_out'
@@ -713,41 +748,6 @@ def setup_optim_problem(self, prices: dict, timegrid:Timegrid = None, costs_only
             return OptimProblem(c = c, l = l, u = u,
                                 mapping = mapping)
 
-    def make_vector(self, value:  Union[float, StartEndValueDict, str], prices:dict, default_value: float = None, convert=False):
-        """
-        Make a vector out of value
-        Args:
-            value (float, dict, str): The value to be converted to a vector
-                                      float: constant value
-                                      dict:  dict['start'] = array
-                                             dict['end']   = array
-                                             dict['values'] = array
-                                      str:   refers to column in "prices" data that provides time series to set up OptimProblem (as for "price" below)
-            prices (dict): Dictionary of price arrays needed by assets in portfolio
-            default_value (float): The value that is used if any of the entries of the resulting vector are not specified
-
-        Returns:
-
-        """
-        I = self.timegrid.restricted.I  # indices of restricted time grid
-        T = self.timegrid.restricted.T
-        if value is None:
-            return value
-        elif isinstance(value, (float, int, np.ndarray)):
-            vec = value * np.ones(T)
-        elif isinstance(value, str):
-            assert (value in prices), 'data for ' + value + ' not found for asset  ' + self.name
-            vec = prices[value].copy()
-            if isinstance(vec, pd.Series): vec = vec.values # may be given as Series (prices as DataFrame) (nor preferred, but sometimes handy)
-            vec = vec[I]  # only in asset time window
-        else:  # given in form of dict (start/end/values)
-            vec = self.timegrid.restricted.values_to_grid(value)
-            if default_value is not None:
-                vec[np.isnan(vec)] = default_value
-
-        if convert:
-            vec = vec * self.timegrid.restricted.dt
-        return vec
 
 class Transport(Asset):
     """ Contract Class """
@@ -2606,3 +2606,141 @@ def __init__(self,
                                        consumption_if_on = consumption_if_on,
                                        _no_heat = True)
 
+
+class OrderBook(Asset):
+    """ Contract Class """
+    def __init__(self,
+                name:   str  = 'default_name_order_book',
+                nodes:  Node = Node(name = 'default_node'),
+                wacc:   float = 0,
+                orders: Dict = None,
+                full_exec: bool = False):
+        """ Order book: Provide a list of orders that are available for execution. Orders come with start, end (of delivery), capacity & price
+
+        Args:
+            name (str): Unique name of the asset                                              (asset parameter)
+            node (Node): Node, the constract is located in                                    (asset parameter)
+            timegrid (Timegrid): Timegrid for discretization                                  (asset parameter)
+            wacc (float): Weighted average cost of capital to discount cash flows in target   (asset parameter)
+            orders (dict or pd.DataFrame) :  Available orders for execution
+                                      dict:  dict['start'] = array of np.TimeStamps
+                                             dict['end']   = array of np.TimeStamps
+                                             dict['capa']  = array of float
+                                             dict['price'] = array of float                                  
+            full_exec (bool, optional): Enforce full execution of orders (defaults to False - partial execution allowed)
+
+        """
+        super(OrderBook, self).__init__(name    = name,
+                                             nodes   = nodes,
+                                             start   = None,
+                                             end     = None,
+                                             wacc    = wacc,
+                                             freq    = None,
+                                             profile = None)
+        if isinstance(orders, pd.DataFrame):
+            myorders = dict()
+            for col in orders.columns:
+                myorders[col] = orders[col].values
+            orders = myorders
+        if isinstance(orders, Dict):
+            assert 'start' in orders.keys(), '"start" dates must be given for orders'
+            assert 'end'   in orders.keys(), '"end"   dates must be given for orders'
+            assert 'capa'  in orders.keys(), '"capa"  values must be given for orders'
+            assert 'price' in orders.keys(), '"price" values must be given for orders'
+            assert len(orders['start']) == len(orders['end']), 'order must have same number of start and end values   ' + str(name)
+            assert len(orders['start']) == len(orders['end']), 'order must have same number of start and end values   ' + str(name)            
+            assert len(orders['start']) == len(orders['capa']), 'order must have same number of start and capa values   ' + str(name)
+            assert len(orders['start']) == len(orders['price']), 'order must have same number of start and price values   ' + str(name)                        
+        else:
+            raise ValueError('Order Book bust be Dictionary (start, end, capa, price) or pd.Dataframe   -  '+str(name))
+
+        self.orders = orders
+        self.full_exec = full_exec
+
+
+    @abc.abstractmethod
+    def setup_optim_problem(self, prices: dict = None, timegrid:Timegrid = None, costs_only:bool = False) -> OptimProblem:
+        """ Set up optimization problem for asset
+
+        Args:
+            prices (dict): Dictionary of price arrays needed by assets in portfolio --> not required here, for compatibility
+            timegrid (Timegrid, optional): Discretization grid for asset. Defaults to None,
+                                           in which case it must have been set previously
+            costs_only (bool): Only create costs vector (speed up e.g. for sampling prices). Defaults to False
+
+        Returns:
+            OptimProblem: Optimization problem to be used by optimizer
+        """
+        # set timegrid if given as optional argument
+        if not timegrid is None:
+            self.set_timegrid(timegrid)
+        else:
+            pass # timegrid = self.timegrid
+        # check: timegrid set?
+        if not hasattr(self, 'timegrid'):
+            raise ValueError('Set timegrid of asset before creating optim problem. Asset: '+ self.name)
+
+        ##### using restricted timegrid for asset lifetime (save resources)
+        I                = self.timegrid.restricted.I # indices of restricted time grid
+        T                = self.timegrid.restricted.T # length of restr. grid
+        tp               = self.timegrid.restricted.timepoints
+        dt               = self.timegrid.restricted.dt
+        discount_factors = self.timegrid.restricted.discount_factors # disc fctrs of restr. grid
+
+        # # Make vector of single min/max capacities.
+        # max_cap = self.make_vector(self.max_cap, prices, convert=True)
+        # min_cap = self.make_vector(self.min_cap, prices, convert=True)
+
+        # # check integrity
+        # if any(min_cap>max_cap):
+        #     raise ValueError('Asset --' + self.name+'--: Contract with min_cap > max_cap leads to ill-posed optimization problem')
+
+        # # Make vector of extra_costs:
+        # extra_costs = self.make_vector(self.extra_costs, prices, default_value=0)
+
+        mapping = pd.DataFrame(columns=['time_step',
+                                        'var_name',
+                                        'disp_factor']) 
+        
+        # loop over orders. each order has one variable "execute" from [0,1], forced bool if chosen
+        # mapping will enconde which time steps are affected
+        n = len(self.orders['start']) # number of orders
+        l = np.zeros(n)
+        u = np.ones(n)
+        c = np.zeros(n) # filled in loop
+        for iO in range(0, len(self.orders['start'])):
+            mys = self.orders['start'][iO]
+            mye = self.orders['end'][iO]
+            myc = self.orders['capa'][iO] 
+            myp = self.orders['price'][iO]                        
+            # number of timesteps affected
+            myI = (tp>=mys) & (tp<mye)
+            # price for whole duration! discounting as if paid each time step
+            c[iO] = myc * sum(dt[myI] * discount_factors[myI]) *myp # sign (buy/sell in price as exec [0,1])
+            mymap = pd.DataFrame() 
+            mymap['time_step']   = I[myI]    # order valid here
+            mymap['disp_factor'] = myc * dt[myI]  # order exec [0,1], effect capa incl. sign buy/sell
+            mymap['var_name']    = iO
+            mymap.index = mymap['var_name'].values
+            if len(mapping)==0: mapping = mymap.copy()
+            else: mapping = pd.concat([mapping, mymap.copy()])
+            pass
+        # shortcut if only costs required
+        if costs_only:
+            return c
+        # common entries
+        mapping['asset'] = self.name
+        mapping['type']  = 'd' # dispatch variable
+        mapping['node']  = self.node_names[0]
+        # if full exec, our variables are boolean (0,1)
+        if self.full_exec: mapping['bool']  = self.full_exec
+
+        # if we're using a less granular asset timegrid, add dispatch for every minor grid point
+        # Effectively we concat the mapping for each minor point (one row each)
+        if hasattr(self.timegrid.restricted, 'I_minor_in_major'):
+            # mapping = self.__extend_mapping_to_minor_grid__(mapping)
+            raise ValueError('should not happen')
+
+        return OptimProblem(c = c, l = l, u = u,
+                            mapping = mapping,
+                            timegrid = self.timegrid)
\ No newline at end of file
diff --git a/eaopack/io.py b/eaopack/io.py
index 37e8d90..2810efa 100644
--- a/eaopack/io.py
+++ b/eaopack/io.py
@@ -47,7 +47,7 @@ def extract_output(portf: Portfolio, op: OptimProblem, res:Results, prices: dict
         disp    = pd.DataFrame(index = times) # dispatch
         internal_variables = pd.DataFrame(index = times)
         duals   = pd.DataFrame(index = times) # duals of problem -  correspond to nodal prices
-        special = pd.DataFrame(columns=['asset', 'variable', 'value', 'costs']) # one line per asset / parameter
+        special = pd.DataFrame(columns=['asset', 'variable', 'name', 'value', 'costs']) # one line per asset / parameter
         # extract dcf for all assets and set together
         for a in portf.assets:
             dcfs[a.name] = a.dcf(optim_problem = op, results = res)
@@ -102,10 +102,26 @@ def extract_output(portf: Portfolio, op: OptimProblem, res:Results, prices: dict
             for i, r in op.mapping[I].iterrows():
                 myrow = {'asset'      : r.asset,
                          'variable'   : r.type,
+                         'name'       : r.var_name,
                          'value'      : res.x[i],
                          'costs'      : res.x[i]*op.c[i]
                            }
-                special = special.append(myrow, ignore_index = True)
+                # special = special.append(myrow, ignore_index = True)
+                special.loc[len(special)] = myrow
+            # extract orders as special case of ORDER BOOK asset
+            if isinstance(a, serialization.OrderBook):
+                # extract order information
+                my_mapping =  op.mapping.loc[op.mapping['asset']==a.name].copy()
+                # drop duplicate index - since mapping may contain several rows per varaible (indexes enumerate variables)
+                my_mapping = pd.DataFrame(my_mapping[~my_mapping.index.duplicated(keep = 'first')])                
+                for i, r in my_mapping.iterrows(): # only orders, only unique
+                    myrow = {'asset'     : r.asset,
+                            'variable'   : r.type,
+                            'name'       : r.var_name,
+                            'value'      : res.x[i],
+                            'costs'      : res.x[i]*op.c[i]
+                            }
+                    special.loc[len(special)] = myrow
         # add given prices to duals in output (relevant reference)
         if not prices is None:
             for myc in prices:
diff --git a/eaopack/serialization.py b/eaopack/serialization.py
index 179a5fc..0d5fd96 100644
--- a/eaopack/serialization.py
+++ b/eaopack/serialization.py
@@ -56,6 +56,11 @@ def json_serialize_objects(obj) -> dict:
         # res.pop('timegrid', None) # not to be serialized
         res['__class__']  = 'Asset' # super class Asset
         res['asset_type'] = obj.__class__.__name__ # store child class
+        if res['asset_type'] == 'OrderBook': # some parameters not relevant
+            res.pop('start', None)
+            res.pop('end', None)
+            res.pop('freq', None)
+            res.pop('profile', None)
     elif isinstance(obj, Portfolio):
         res = {'assets': obj.assets}
         if hasattr(obj, 'timegrid'):
diff --git a/requirements.txt b/requirements.txt
index bf299f4..bb0dcbe 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,8 +1,8 @@
-matplotlib
-numpy
-pandas
-scipy
-networkx
-cvxpy  
-cvxopt
-openpyxl
+matplotlib == 3.9.2
+numpy == 2.1.3
+pandas == 2.2.3
+scipy == 1.14.1
+networkx == 3.3
+cvxpy == 1.5.3
+cvxopt == 1.3.2
+openpyxl == 3.1.5
diff --git a/setup.cfg b/setup.cfg
index 26b6ae5..f6eeb4d 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,6 +1,6 @@
 [metadata]
 name = eaopack
-version = 2.1.0
+version = 2.1.1
 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/.github/workflows/unittests_doc.yml b/.github/workflows/unittests_doc.yml
index 7ff94c5..2bc6273 100644
--- a/.github/workflows/unittests_doc.yml
+++ b/.github/workflows/unittests_doc.yml
@@ -22,11 +22,11 @@ jobs:
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       # Installs python
       - name: Setup Python
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v5
         with:
           python-version: 3.12.2
           architecture: 'x64'
@@ -75,7 +75,7 @@ jobs:
         # run: $CONDA/bin/sphinx-build -b html doc/source/ doc/build
         run: sphinx-build -b html doc/source/ doc/build
       - name: Store doc as artifact
-        uses: actions/upload-artifact@v1
+        uses: actions/upload-artifact@v4
         with:
           name: DocumentationHTML
           path: doc/build/
diff --git a/tests/test_asset.py b/tests/test_asset.py
index c3c14c8..2243fdb 100644
--- a/tests/test_asset.py
+++ b/tests/test_asset.py
@@ -456,7 +456,7 @@ def test_scaled_asset(self):
         portf = eao.portfolio.Portfolio([a,scaled_b])
         op  = portf.setup_optim_problem(prices, timegrid=timegrid)
         res = op.optimize()
-        # out = eao.io.extract_output(portf=portf, op = op, res = res)
+        out = eao.io.extract_output(portf=portf, op = op, res = res)
         # zero costs and limit at original size -- same result
         self.assertAlmostEqual(res_std.value, res.value, 4)
 
@@ -525,6 +525,203 @@ def test_store_cost_with_cap_costs_discount(self):
         self.assertAlmostEqual(res2.value, rev-costs, 1)        
         pass
 
+class TestOrderOrderBooks(unittest.TestCase):
+    def test_order(self):
+        """ Unit test. Basic functioning
+        """
+        node = eao.assets.Node('testNode')
+        timegrid = eao.assets.Timegrid(dt.date(2021,1,1), dt.date(2021,2,1), freq = 'd')
+        tg2 = eao.assets.Timegrid(dt.date(2021,1,1), dt.date(2021,2,1), freq = 'h')
+
+        ## define order book
+        ob = dict( start = [pd.Timestamp(2021,1,1),
+                            pd.Timestamp(2021,1,2),
+                            pd.Timestamp(2021,1,3),
+                            pd.Timestamp(2021,1,7)],
+                   end   = [pd.Timestamp(2021,1,2),
+                            pd.Timestamp(2021,1,5),
+                            pd.Timestamp(2021,1,5),
+                            pd.Timestamp(2021,1,15)],
+                    capa = [-1.1,
+                            -2.2,
+                            3.3,
+                            4.4],
+                    price =[ 8,
+                            12,
+                            13,
+                             9])
+
+
+        a = eao.assets.SimpleContract(name = 'SC', 
+                                      nodes = node,
+                                      price = 'market',
+                                      min_cap= -100., max_cap=100.)
+        order_book = eao.assets.OrderBook(orders=ob, nodes = node)
+        portf = eao.portfolio.Portfolio([a, order_book])
+
+        # test with orderbook being a dataframe and missing key
+        ob_df = pd.DataFrame(ob)
+        ob2   = eao.assets.OrderBook(orders=ob_df)
+        ob_missing = ob.copy()
+        ob_missing.pop('start')
+        try: ob3   = eao.assets.OrderBook(orders=ob_missing)
+        except: pass # should fail
+        else: raise ValueError('Should have raised an arror')
+        prices ={'market': 10*np.ones(timegrid.T)}
+
+        c1 = order_book.setup_optim_problem(prices, timegrid=timegrid, costs_only=True)
+        c2 = order_book.setup_optim_problem(prices, timegrid=tg2, costs_only=True)
+        np.testing.assert_almost_equal(c1, c2, 3)
+
+        # hourly or daily - costs should be the same
+        op = portf.setup_optim_problem(prices, timegrid=timegrid)
+        res = op.optimize()
+        out = eao.io.extract_output(portf= portf, op=op, res=res)
+        self.assertAlmostEqual(out['dispatch'].sum()[1], 4.4*24*8 - 2.2*3*24 , 3)   
+        self.assertAlmostEqual(res.value, 1161.6, 3)   
+
+    def test_order_serialize(self):
+        """ Unit test. serialization
+        """
+        node = eao.assets.Node('testNode')
+        timegrid = eao.assets.Timegrid(dt.date(2021,1,1), dt.date(2021,2,1), freq = 'd')
+
+        ## define order book
+        ob = dict( start = [pd.Timestamp(2021,1,1),
+                            pd.Timestamp(2021,1,2),
+                            pd.Timestamp(2021,1,3),
+                            pd.Timestamp(2021,1,7)],
+                   end   = [pd.Timestamp(2021,1,2),
+                            pd.Timestamp(2021,1,5),
+                            pd.Timestamp(2021,1,5),
+                            pd.Timestamp(2021,1,15)],
+                   capa  = [-1.1,
+                            -2.2,
+                            3.3,
+                            4.4],
+                   price = [ 8,
+                            12,
+                            13,
+                             9])
+        a = eao.assets.SimpleContract(name = 'SC', 
+                                      nodes = node,
+                                      price = 'market',
+                                      min_cap= -100., max_cap=100.)
+        
+        order_book = eao.assets.OrderBook(orders=ob, nodes = node)
+
+        portf = eao.portfolio.Portfolio([a,order_book])
+        s = eao.serialization.to_json(order_book)
+        ob = eao.serialization.load_from_json(s)
+        portf2 = eao.portfolio.Portfolio([a,ob])
+        
+        prices ={'market': 10*np.ones(timegrid.T)}
+        op = portf.setup_optim_problem(prices, timegrid=timegrid)
+        res = op.optimize()
+        op2 = portf2.setup_optim_problem(prices, timegrid=timegrid)
+        res2 = op2.optimize()
+        self.assertAlmostEqual(res.value, res2.value, 3)
+
+    def test_order_enforce_allatonce(self):
+        """ Test enforcing full execution of orders """
+        node = eao.assets.Node('testNode')
+        timegrid = eao.assets.Timegrid(dt.date(2021,1,1), dt.date(2021,2,1), freq = 'h')
+
+        ## define order book
+        ob = dict( start = [pd.Timestamp(2021,1,1, 10),
+                            pd.Timestamp(2021,1,2),
+                            pd.Timestamp(2021,1,3),
+                            pd.Timestamp(2021,1,7)],
+                   end   = [pd.Timestamp(2021,1,6),
+                            pd.Timestamp(2021,1,5, 20),
+                            pd.Timestamp(2021,1,5),
+                            pd.Timestamp(2021,1,15)],
+                    capa = [6,
+                            8,
+                            6,
+                            7],
+                    price =[ 1,
+                             2,
+                             3,
+                             2])
+        a = eao.assets.SimpleContract(name = 'SC', 
+                                      nodes = node,
+                                      price = 'market',
+                                      min_cap= -10., max_cap=0) # restricted sale
+        
+        order_book = eao.assets.OrderBook(orders=ob, nodes = node)
+
+        portf = eao.portfolio.Portfolio([a,order_book])
+        
+        prices ={'market': 10*np.ones(timegrid.T)} # prices above buy prices, so will want to sell
+        op = portf.setup_optim_problem(prices, timegrid=timegrid)
+        res = op.optimize()
+        out = eao.io.extract_output(portf= portf, op=op, res=res)
+        # check all is dispatched
+        self.assertAlmostEqual(out['dispatch'].sum().iloc[1], 2372, 3)
+        self.assertAlmostEqual(out['dispatch'].max().iloc[1], 10, 3) # given by market, orders partly executed
+        # now enforce ecex all
+        order_book = eao.assets.OrderBook(orders=ob, nodes = node, full_exec=True)
+        portf = eao.portfolio.Portfolio([a,order_book])
+        op = portf.setup_optim_problem(prices, timegrid=timegrid)
+        res = op.optimize()
+        out = eao.io.extract_output(portf= portf, op=op, res=res)
+        self.assertAlmostEqual(out['dispatch'].sum().iloc[1], 2004, 3)
+        self.assertAlmostEqual(out['dispatch'].max().iloc[1], 7, 3) # given by market, orders partly executed
+
+    def test_order_book_battery(self):
+        """ Test enforcing full execution of orders """
+        node = eao.assets.Node('power')
+        S = dt.date(2021,1,1)
+        E = dt.date(2021,1,3)
+        timegrid = eao.assets.Timegrid(S, E, freq = 'h')
+        # create larger number of orders
+        ## some time steps, buy & sell
+        ob = pd.DataFrame(columns = ['start', 'end', 'capa', 'price']) # alternative to dict is DataFrame ... converted in asset
+        r = dict() # row
+        ### orders
+        # orders with bid/ask spread on base signal
+        # base signal
+        bs = (20*np.sin(timegrid.I/4)+20).round(0)
+        prices = {'av': bs}
+        for ii in timegrid.I:
+            tp = timegrid.timepoints[ii]
+            # SELL
+            for i in range(0,2):
+                r['start']   = tp
+                r['end']     = tp + pd.Timedelta(3, 'h')
+                r['capa']    = float(i)
+                r['price']   = bs[ii] + float(i)
+                ob.loc[len(ob)] = r
+            # BUY
+            for i in range(0,2):
+                r['start']   = tp
+                r['end']     = tp + pd.Timedelta(4, 'h')
+                r['capa']    = -float(i)
+                r['price']   = bs[ii] + float(i) + 5
+                ob.loc[len(ob)] = r            
+        # battery
+        b = eao.assets.Storage('battery', node, cap_in  = 10, 
+                                                cap_out = 10,
+                                                size    = 40)
+        # last resort - battery end level. May allow battery not to be completely full, "borrowing" in last hours
+        a = eao.assets.SimpleContract('fill_level_adjust', node,
+                                      max_cap=10,
+                                      min_cap=0,
+                                      start=timegrid.timepoints[-2],
+                                      end=E,
+                                      price = 'av',
+                                      extra_costs = 10
+                                      )
+        order_book = eao.assets.OrderBook('orders', node, 
+                                          orders=ob, 
+                                          full_exec = True)  # not exactly required to relax problem
+        portf = eao.portfolio.Portfolio([b, order_book,a])
+        op = portf.setup_optim_problem(prices=prices, timegrid=timegrid)
+        res = op.optimize()
+        out = eao.io.extract_output(portf= portf, op=op, res=res)
+        self.assertAlmostEqual(out['dispatch'].abs().sum().sum(), 192, 3) # recursion test
+
 
 ###########################################################################################################
 ###########################################################################################################