{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Advanced features\n", "\n", "* File name: advanced_features.ipynb\n", "* Last edited: 2020-06-25\n", "* Created by: Stefan Bruche (TU Berlin)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "```python\n", "import copy\n", "import pandas as pd\n", "import aristopy as ar\n", "\n", "# Get data from csv-file \n", "data = pd.read_csv('testdata.csv', sep=';', decimal='.', index_col=[0])\n", "\n", "# USER-INPUT: \"hpts\" (hours per time step)\n", "hpts = 4\n", "\n", "# Aggregate data with \"hours_per_time_step\" for simplification of this notebook\n", "c_elec = ar.utils.aggregate_time_series(data['c_elec [EUR/MWh]'], hpts, 'mean')\n", "q_demand = ar.utils.aggregate_time_series(data['Q_demand [MWh]'], hpts, 'sum')\n", "\n", "# Create energy system instance\n", "es = ar.EnergySystem(\n", " number_of_time_steps=8760//hpts, hours_per_time_step=hpts,\n", " interest_rate=0.05, economic_lifetime=20, logging=ar.Logger(\n", " default_log_handler='file', default_log_level='INFO', \n", " write_screen_output_to_logfile=True))\n", "\n", "# Add a gas source, a heat and electricity sink and a heat bus for collecting\n", "gas_source = ar.Source(\n", " ensys=es, name='gas_source', commodity_cost=20, outlet=ar.Flow('Fuel'))\n", "\n", "heat_sink = ar.Sink(\n", " ensys=es, name='heat_sink', inlet=ar.Flow('Heat', link='heat_bus'),\n", " commodity_rate_fix=ar.Series('q_demand', q_demand))\n", "\n", "elec_sink = ar.Sink(\n", " ensys=es, name='elec_sink', inlet=ar.Flow('Elec'),\n", " commodity_revenues=ar.Series('c_elec', c_elec))\n", "\n", "heat_bus = ar.Bus(\n", " ensys=es, name='heat_bus',\n", " inlet=ar.Flow('Heat', var_name='Heat_inlet'),\n", " outlet=ar.Flow('Heat', var_name='Heat_outlet'))\n", "\n", "gas_boiler = ar.Conversion(\n", " ensys=es, name='gas_boiler', basic_variable='Heat',\n", " inlet=ar.Flow('Fuel', 'gas_source'), outlet=ar.Flow('Heat', 'heat_bus'),\n", " capacity_max=250, capex_per_capacity=60e3,\n", " user_expressions='Heat == 0.9 * Fuel')\n", "\n", "# Add a group of 5 gas engine units with fixed size\n", "gas_engine = ar.Conversion(\n", " ensys=es, name='gas_engine', basic_variable='Elec',\n", " inlet=ar.Flow('Fuel', 'gas_source'),\n", " outlet=[ar.Flow('Heat', 'heat_bus'), ar.Flow('Elec', 'elec_sink')],\n", " has_existence_binary_var=True, has_operation_binary_var=True,\n", " additional_vars=ar.Var('Load', ub=1), scalar_params={'dt': hpts},\n", " capacity=20, min_load_rel=0.2,\n", " user_expressions=['Load <= BI_OP',\n", " 'Elec == (20 * Load) * dt',\n", " 'Heat <= (17 * Load + 2.5 * BI_OP) * dt',\n", " 'Fuel == (37 * Load + 7 * BI_OP) * dt'],\n", " capex_per_capacity=1000e3, opex_per_capacity=12.5e3, opex_operation=6,\n", " instances_in_group=5)\n", "\n", "# Add a heat storage component\n", "heat_storage = ar.Storage(\n", " ensys=es, name='heat_storage',\n", " inlet=ar.Flow('Heat', link='heat_bus', var_name='Heat_charge'),\n", " outlet=ar.Flow('Heat', link='heat_bus', var_name='Heat_discharge'),\n", " has_existence_binary_var=True,\n", " maximal_module_number=5, capacity_per_module=50, # max: 5 * 50 MWh\n", " capex_per_capacity=12e3, opex_per_capacity=0.015*12e3, # 12,000 €/MWh CAPEX\n", " self_discharge=0.01, charge_rate=1/6, discharge_rate=1/6,\n", " opex_operation=1e-9, use_inter_period_formulation=False)\n", "\n", "# Use a backdoor to the pyomo model instance and add a user-defined constraint\n", "# specifying the installed nominal thermal capacity needs to be at least 220 MW.\n", "def minimal_installed_capacity_heat(ensys, m):\n", " expr = 0\n", " for comp in ensys.components.values():\n", " if comp.name == 'gas_boiler':\n", " expr += comp.block.CAP\n", " elif comp.group_name == 'gas_engine':\n", " expr += 19.5 * comp.block.BI_EX\n", " return expr >= 220\n", "es.add_constraint(name='min_cap_heat', has_time_set=False,\n", " rule=minimal_installed_capacity_heat)\n", "\n", "\n", "# Create a deepcopy of the original (full scale) model instance for later use\n", "original_model = copy.deepcopy(es)\n", "\n", "\n", "# Conventional optimization:\n", "# ~~~~~~~~~~~~~~~~~~~~~~~~~~\n", "# Run the optimization of the original model instance\n", "es.optimize(solver='gurobi', time_limit=300, optimization_specs='mipgap=5e-3')\n", "\n", "\n", "# Time series clustering:\n", "# ~~~~~~~~~~~~~~~~~~~~~~~\n", "# Cluster time series data to 20 typical days.\n", "es.cluster(number_of_typical_periods=20,\n", " number_of_time_steps_per_period=24//hpts)\n", "\n", "# Use aggregated data to run the optimization\n", "es.optimize(use_clustered_data=True)\n", "\n", "# Plot results for a single period and scaled to full year with hourly resolution\n", "plotter = ar.Plotter('results.json')\n", "plotter.plot_operation('heat_storage', 'Heat', ylabel='Thermal energy [MWh]',\n", " file_name='heat_storage', plot_single_period_with_index=7)\n", "plotter.plot_operation('heat_bus', 'Heat', ylabel='Thermal energy [MWh]', \n", " file_name='heat_bus', scale_to_hourly_resolution=True)\n", "\n", "\n", "# Two-stage model run:\n", "# ~~~~~~~~~~~~~~~~~~~~\n", "# Construct (declare) a persistent model of the original (full scale) instance\n", "original_model.declare_model(use_clustered_data=False, declare_persistent=True)\n", "\n", "# Cluster time series data, declare the model and relax the integrality of the\n", "# binary operation variables\n", "es.cluster(number_of_typical_periods=20,\n", " number_of_time_steps_per_period=24 // hpts)\n", "es.declare_model(use_clustered_data=True)\n", "es.relax_integrality(include_time_dependent=True, \n", " include_existence=False, include_modules=False)\n", "\n", "# Iteratively run the model (1st stage and 2nd stage)\n", "for icc in range(3):\n", "\n", " # Run optimization with clustered data\n", " es.optimize(use_clustered_data=True, declare_model=False,\n", " tee=False, results_file=f'1st_stage_results_{icc}.json')\n", "\n", " # Export the configuration to a DataFrame and store it in an Excel-File\n", " config = es.export_component_configuration(\n", " write_to_excel=True, file_name=f'1st_stage_config_{icc}.xlsx')\n", "\n", " # Import the optimal configuration and fix design variables\n", " original_model.import_component_configuration(config)\n", "\n", " # Run the already declared persistent, full scale model\n", " original_model.optimize(declare_model=False, tee=False,\n", " results_file=f'2nd_stage_results_{icc}.json')\n", "\n", " # Reset variables to their original (unfixed) values\n", " original_model.reset_component_variables()\n", "\n", " # Add an integer-cut constraint for the gas engines to the aggregated model\n", " # => Exclude previously found optimal design from the solution space\n", " es.add_design_integer_cut_constraint(which_instances=['gas_engine'])\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Data and model\n", "\n", "Read the input data from a csv-file for one year in hourly resolution (8760 time steps) with pandas." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Import the required packages (jupyter magic only required for jupyter notebooks)\n", "%reload_ext autoreload\n", "%autoreload 2\n", "%matplotlib inline\n", "\n", "import copy\n", "import pandas as pd\n", "import aristopy as ar\n", "\n", "# Get data from csv-file \n", "data = pd.read_csv('testdata.csv', sep=';', decimal='.', index_col=[0])" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
c_elec [EUR/MWh]Q_demand [MWh]
01.01.2018 00:00-5.2751.828932
01.01.2018 01:00-29.9951.123716
01.01.2018 02:00-56.6549.202127
01.01.2018 03:00-63.1449.060032
01.01.2018 04:00-64.6252.669893
01.01.2018 05:00-67.0059.055207
01.01.2018 06:00-72.5464.771925
01.01.2018 07:00-76.0166.424269
\n", "
" ], "text/plain": [ " c_elec [EUR/MWh] Q_demand [MWh]\n", "01.01.2018 00:00 -5.27 51.828932\n", "01.01.2018 01:00 -29.99 51.123716\n", "01.01.2018 02:00 -56.65 49.202127\n", "01.01.2018 03:00 -63.14 49.060032\n", "01.01.2018 04:00 -64.62 52.669893\n", "01.01.2018 05:00 -67.00 59.055207\n", "01.01.2018 06:00 -72.54 64.771925\n", "01.01.2018 07:00 -76.01 66.424269" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# print the first 8 rows\n", "data.head(8)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Aggregate the data for simplification purposes in this notebook by summing/averaging over 4 hours. There is a built-in function in the file utils.py to assist in completing this task." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(array([-38.7625, -70.0425, -64.1025, ..., 61.3 , 64.1375, 43.5775]),\n", " array([201.21480811, 242.92129394, 306.69530448, ..., 432.8322987 ,\n", " 463.4687946 , 381.27112154]))" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# USER-INPUT: \"hpts\" (hours per time step)\n", "hpts = 4\n", "\n", "# Aggregate data with \"hours_per_time_step\" for simplification of this notebook\n", "c_elec = ar.utils.aggregate_time_series(data['c_elec [EUR/MWh]'], hpts, 'mean')\n", "q_demand = ar.utils.aggregate_time_series(data['Q_demand [MWh]'], hpts, 'sum')\n", "\n", "# Show aggregated data on screen\n", "c_elec, q_demand" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As in the first example, first, an energy system instance must be created as the main model container. This time an additional logger is added to store information about the modeling and solving process in a log-file. Moreover, a gas source and electricity and heat sinks are added." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Create energy system instance\n", "es = ar.EnergySystem(\n", " number_of_time_steps=8760//hpts, hours_per_time_step=hpts,\n", " interest_rate=0.05, economic_lifetime=20, logging=ar.Logger(\n", " default_log_handler='file', default_log_level='INFO', \n", " write_screen_output_to_logfile=True))\n", "\n", "# Add a gas source, a heat and electricity sink and a heat bus for collecting\n", "gas_source = ar.Source(\n", " ensys=es, name='gas_source', commodity_cost=20, outlet=ar.Flow('Fuel'))\n", "\n", "heat_sink = ar.Sink(\n", " ensys=es, name='heat_sink', inlet=ar.Flow('Heat', link='heat_bus'),\n", " commodity_rate_fix=ar.Series('q_demand', q_demand))\n", "\n", "elec_sink = ar.Sink(\n", " ensys=es, name='elec_sink', inlet=ar.Flow('Elec'),\n", " commodity_revenues=ar.Series('c_elec', c_elec))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The bus component collects all heat flows at the inlet and transports them (with or without losses) to the outlet. \n", "\n", "
\n", "\n", "**Note:** \n", "\n", "The same commodity is present at the inlet and the outlet. Therefore, different names for the created variables must be specified in the corresponding flows.\n", "
" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "heat_bus = ar.Bus(\n", " ensys=es, name='heat_bus',\n", " inlet=ar.Flow('Heat', var_name='Heat_inlet'),\n", " outlet=ar.Flow('Heat', var_name='Heat_outlet'))\n", "\n", "gas_boiler = ar.Conversion(\n", " ensys=es, name='gas_boiler', basic_variable='Heat',\n", " inlet=ar.Flow('Fuel', 'gas_source'), outlet=ar.Flow('Heat', 'heat_bus'),\n", " capacity_max=250, capex_per_capacity=60e3,\n", " user_expressions='Heat == 0.9 * Fuel')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we add five gas engine instances with identical specifications that are simultaneously created and arranged in a group (see \"instances_in_group\"). The five components can work independently, but have an order for their binary existence and operation variables (see API of the [Conversion class](conversion.rst))." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Add maximal 5 gas engine units with fixed size\n", "gas_engine = ar.Conversion(\n", " ensys=es, name='gas_engine', basic_variable='Elec',\n", " inlet=ar.Flow('Fuel', 'gas_source'),\n", " outlet=[ar.Flow('Heat', 'heat_bus'), ar.Flow('Elec', 'elec_sink')],\n", " has_existence_binary_var=True, has_operation_binary_var=True,\n", " additional_vars=ar.Var('Load', ub=1), scalar_params={'dt': hpts},\n", " capacity=20, min_load_rel=0.2,\n", " user_expressions=['Load <= BI_OP',\n", " 'Elec == (20 * Load) * dt',\n", " 'Heat <= (17 * Load + 2.5 * BI_OP) * dt',\n", " 'Fuel == (37 * Load + 7 * BI_OP) * dt'],\n", " capex_per_capacity=1000e3, opex_per_capacity=12.5e3, opex_operation=6,\n", " instances_in_group=5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The performance modeling in the user expressions of the gas engines involves using binary operating variables (default name \"BI_OP\" is defined in file utils.py). Due to the y-axis intercept, the resulting efficiency curves show non-linear characteristics.\n", "\n", "
\n", "\n", "**Note:** \n", "\n", "If required, we could also introduce time-varying parameters in the user-expressions to describe the dependency of the conversion rates on, e.g., ambient conditions.\n", "
" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "idx = np.linspace(0.2, 1, 20)\n", "plt.plot(idx, (20*idx)/(37*idx+7)*100, label='el. efficiency')\n", "plt.plot(idx, (17*idx+2.5)/(37*idx+7)*100, label='th. efficiency')\n", "plt.xlabel('Load [-]'), plt.ylabel('Efficiency [%]'), plt.legend(loc=4)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A heat storage component is also included in the design. The storage tank has a modular design and can consist of up to 5 modules of 50 MWh. It should be noted that, similar to the bus component, different variable names must be specified for the inlet and outlet flows. The small value for the argument \"opex_operation\" is set to prevent simultaneous loading and unloading of the storage. For all other keyword arguments, please consult the documentation of the [storage class API](storage.rst)." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Add a heat storage component\n", "heat_storage = ar.Storage(\n", " ensys=es, name='heat_storage',\n", " inlet=ar.Flow('Heat', link='heat_bus', var_name='Heat_charge'),\n", " outlet=ar.Flow('Heat', link='heat_bus', var_name='Heat_discharge'),\n", " has_existence_binary_var=True,\n", " maximal_module_number=5, capacity_per_module=50, # max: 5 * 50 MWh\n", " capex_per_capacity=12e3, opex_per_capacity=0.015*12e3, # 12,000 €/MWh CAPEX\n", " self_discharge=0.01, charge_rate=1/6, discharge_rate=1/6,\n", " opex_operation=1e-9, use_inter_period_formulation=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we introduce a constraint that the total installed thermal capacity of the gas boiler and all gas engines must be at least 220 MW. To add this condition to the model, we use a back door to the main pyomo model instance, accessible via the method ```add_constraint``` of the energy system. It must be determined whether the constraint is time-dependent (or has a different set), and a function must be assigned as the constraint rule. This function needs to have at least two arguments. The first one represents the energy system instance; the second one is the pyomo model instance. For a time-dependent constraint, we would need to add two more arguments, representing period (p) and time-step (t).
\n", "Furthermore, *aristopy* offers the possibility to add additional variables and objective function contributions to the main pyomo model instance. The functions ```add_variable``` and ```add_objective_function_contribution``` are available for this purpose. Please consult the API of the [EnergySystem class](energySystem.rst) for further information." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# Use a backdoor to the pyomo model instance and add a user-defined constraint\n", "# specifying the installed nominal thermal capacity needs to be at least 220 MW.\n", "def minimal_installed_capacity_heat(ensys, m):\n", " expr = 0\n", " for comp in ensys.components.values():\n", " if comp.name == 'gas_boiler':\n", " expr += comp.block.CAP\n", " elif comp.group_name == 'gas_engine':\n", " expr += 19.5 * comp.block.BI_EX\n", " return expr >= 220\n", "es.add_constraint(name='min_cap_heat', has_time_set=False,\n", " rule=minimal_installed_capacity_heat)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Before we pass the developed model to a solver, we create a copy by using the method ```deepcopy``` of the copy-package. We will use this original model instance later." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# Create a deepcopy of the original (full scale) model instance for later use\n", "original_model = copy.deepcopy(es)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Conventional optimization\n", "\n", "As in the first example, the model can simply be by calling the method ```optimize``` of the energy system instance. To control the solving process, we add a time limitation in seconds and a requested relative MIP-gap to the solver Gurobi. " ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# Run the optimization of the original model instance\n", "es.optimize(solver='gurobi', time_limit=300, optimization_specs='mipgap=1e-3', \n", " results_file='full_scale_results.json', tee=False)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'solver_name': 'gurobi',\n", " 'time_limit': 300,\n", " 'optimization_specs': 'mipgap=1e-3',\n", " 'model_build_time': 4,\n", " 'model_solve_time': 308,\n", " 'upper_bound': -163634109.14349702,\n", " 'lower_bound': -163920996.8127097,\n", " 'sense': 'maximize',\n", " 'solver_status': 'aborted',\n", " 'termination_condition': 'maxTimeLimit'}" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# show basic information about the model building and solving process\n", "es.run_info" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The optimal design solution of the original (full scale) model instance can be accessed with the ```export_component_configuration``` method and is stated in the table below. The objective function contributions of the individual components are shown in the following figure." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
gas_sourceheat_sinkelec_sinkheat_busgas_boilergas_engine_1gas_engine_2gas_engine_3gas_engine_4gas_engine_5heat_storage
BI_EXNoneNoneNoneNoneNone1111-01
BI_MODULE_EXNoneNoneNoneNoneNoneNoneNoneNoneNoneNone{1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0, 5: -0.0}
CAPNoneNoneNoneNone142202020200200
\n", "
" ], "text/plain": [ " gas_source heat_sink elec_sink heat_bus gas_boiler gas_engine_1 \\\n", "BI_EX None None None None None 1 \n", "BI_MODULE_EX None None None None None None \n", "CAP None None None None 142 20 \n", "\n", " gas_engine_2 gas_engine_3 gas_engine_4 gas_engine_5 \\\n", "BI_EX 1 1 1 -0 \n", "BI_MODULE_EX None None None None \n", "CAP 20 20 20 0 \n", "\n", " heat_storage \n", "BI_EX 1 \n", "BI_MODULE_EX {1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0, 5: -0.0} \n", "CAP 200 " ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "es.export_component_configuration()" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "ar.Plotter('full_scale_results.json').plot_objective(show_plot=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Time series clustering\n", "\n", "To reduce the number of variables and to speed up the calculation, we can perform the optimization for only a few typical periods. To do this, we first call the ```cluster``` method and break the time series data into elements of equal length and combine similar items into clusters. In the example below, 20 typical days are formed from the input data, and the optimization is performed with these aggregated data (\"use_clustered_data\" is True)." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# Cluster time series data to 20 typical days.\n", "es.cluster(number_of_typical_periods=20,\n", " number_of_time_steps_per_period=24//hpts)\n", "\n", "# Use clustered data to run the optimization\n", "es.optimize(use_clustered_data=True, tee=False, results_file='clustered_results.json')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The required time to build and solve the model can be reduced significantly by using clustered input data. The optimal design solution found is comparable to the one of the original model." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'solver_name': 'gurobi',\n", " 'time_limit': None,\n", " 'optimization_specs': '',\n", " 'model_build_time': 0,\n", " 'model_solve_time': 2,\n", " 'upper_bound': -170278358.02702567,\n", " 'lower_bound': -170278358.02702567,\n", " 'sense': 'maximize',\n", " 'solver_status': 'ok',\n", " 'termination_condition': 'optimal'}" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "es.run_info" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
gas_sourceheat_sinkelec_sinkheat_busgas_boilergas_engine_1gas_engine_2gas_engine_3gas_engine_4gas_engine_5heat_storage
BI_EXNoneNoneNoneNoneNone111-0-01
BI_MODULE_EXNoneNoneNoneNoneNoneNoneNoneNoneNoneNone{1: 1.0, 2: 1.0, 3: 1.0, 4: -0.0, 5: -0.0}
CAPNoneNoneNoneNone161.5202020-0-0150
\n", "
" ], "text/plain": [ " gas_source heat_sink elec_sink heat_bus gas_boiler gas_engine_1 \\\n", "BI_EX None None None None None 1 \n", "BI_MODULE_EX None None None None None None \n", "CAP None None None None 161.5 20 \n", "\n", " gas_engine_2 gas_engine_3 gas_engine_4 gas_engine_5 \\\n", "BI_EX 1 1 -0 -0 \n", "BI_MODULE_EX None None None None \n", "CAP 20 20 -0 -0 \n", "\n", " heat_storage \n", "BI_EX 1 \n", "BI_MODULE_EX {1: 1.0, 2: 1.0, 3: 1.0, 4: -0.0, 5: -0.0} \n", "CAP 150 " ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "es.export_component_configuration()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following figures show the state of charge (SOC) of the heat storage tank and the associated loading and unloading operations for a selected typical period. Besides, the heat flows, entering and leaving the heat bus component are plotted scaled to a full year cycle." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAt4AAAG+CAYAAACkiAOYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdfVhU1d74//dAKKhonHy4yLpEu1KSAYaB4VGRVMTT8Zyv+JCZt4mW+VDq6RTfG+2k6W1GX6xMyyi/KunRE0mH8qTdEvdPbsSQRwdRRIlEybwM/R4QSQtk//4g9g0yg4M8zICf13VxKWv2Xuuz9uxhPrNm7bU1iqIghBBCCCGE6Fx21g5ACCGEEEKIe4Ek3kIIIYQQQnQBSbyFEEIIIYToApJ4CyGEEEII0QUk8RZCCCGEEKILSOIthBBCCCFEF7jP2gF0toEDBypubm7WDkN0kdzYcPxivrljmRBCCCFEZ8jLy7uiKMogU4/1+MTbzc2N3Nxca4chukrqypbPt6kyIYQQQohOoNFozpt7TKaaCCGEEEII0QUk8RZCCCGEEKILSOIthBBCCCFEF+jxc7yFEN3DTz/9xCuvvEJxcTH19fXWDkcIm2BnZ4e7uzsbN25k8ODB1g5HCNFOkngLIWzCK6+8wuOPP8727dtxcHCwdjhC2ITa2lp2797NK6+8wq5du6wdjhCinWSqiRDCJhQXF/Nv//ZvknQL0YSDgwNz586luLjY2qEIITqAJN6iZ0tdae0IhIXq6+sl6RbCBAcHB5l+JUQPIYm3EEIIIYQQXUDmeAshbJJbzIEOra8s9g8dWp819evXj+vXr1u8/erVqwkNDWXixImEhYWxceNG/Pz87qrtsrIypkyZwsmTJ+9q/6bS0tLo1asXwcHBZreJiopiypQpzJgxo93tNXX7MUxISCA3N5f333+/zXUZjUZ+/PFHnnjiiY4MUQjRA8mItxBCtMGtW7esHUKbrVu3jokTJ97Vvp3Z37S0NL799ttOq7+rGI1GDh48aO0whBDdgCTeQgjRxNSpU/H19cXDw4OPP/4YaBgdXb16NQEBAWRmZpKTk0NwcDDe3t74+/tTXV3dop6cnBy8vLwICgoiOjoarVYLNIwYjx07Fr1ej16vVxPPS5cuERoaik6nQ6vVcuTIkVbjfPnll9Hr9UyYMIGKigqgIQEMDAzEy8uLyMhI/vWvfwENo8ZJSUkt6khJSSEoKAi9Xs/MmTPVEWA3NzfWrVvHmDFj2LdvX4v9bt26xcKFC/Hw8GDSpEncuHEDgNLSUiZPnoyvry9jx45VLwj85z//SUBAAD4+PkycOJHLly9TVlZGfHw87777LjqdrtX+pqamMnbsWEaOHMlXX30FNIxQv/jii+o2U6ZMIS0tjVu3bhEVFYVWq8XT05N333231eNoSkVFBdOnT8dgMGAwGDh69CgA2dnZBAcH4+PjQ3BwMGfOnOHXX39l9erVJCYmotPpSExMbHN7Qoh7hyTeQgjRxI4dO8jLyyM3N5fNmzdz9epVampq0Gq1ZGVl4e/vz6xZs3jvvfcoKCggNTUVJyenFvXMnz+f+Ph4MjMzsbe3V8sHDx7MN998Q35+PomJiSxfvhyAvXv3EhERgdFopKCgAJ1OZzbGmpoa9Ho9+fn5jBs3jrVr1wLwzDPP8NZbb3HixAk8PT3VclOuXLnC+vXrSU1NJT8/Hz8/P9555x31cUdHRzIyMnjqqada7FtSUsILL7zAqVOnuP/++/n8888BeP7559myZQt5eXls3LiRpUuXAjBmzBiOHTvG8ePHeeqpp/g//+f/4ObmxuLFi3nppZcwGo2MHTvWbKxlZWX893//NwcOHGDx4sXcvHnT7LZGo5GLFy9y8uRJCgsLmT9/vsntbty4gU6nU39Wr16tPrZixQpeeuklcnJy+Pzzz3nuuecAcHd3Jz09nePHj7Nu3TpWrVpFr169WLduHbNmzcJoNDJr1iyzsQkhhMzxFj1T6kqY+Oady4S4zebNm0lOTgagvLyckpIS7O3tmT59OgBnzpzB1dUVg8EAQP/+/VvUUVlZSXV1tTp3+emnn1ZHamtra3nxxRcxGo3Y29tz9uxZAAwGAwsWLKC2tpapU6e2mnjb2dmpCd6//du/MW3aNKqqqqisrGTcuHEAzJs3j5kzZ5qt49ixYxQVFRESEgLAr7/+SlBQkPp4awnk8OHD1fh8fX0pKyvj+vXrfPvtt83a/OWXXwD44YcfmDVrFpcuXeLXX39l+PDhZus25cknn8TOzo5HH32UESNGtLq03ogRI/j+++9ZtmwZf/jDH5g0aZLJ7ZycnDAajervjXO8oWGEvaioSH3s2rVrVFdXU1VVxbx58ygpKUGj0VBbW9umfgghhIx4i57H1BKCsqygsEBaWhqpqalkZmZSUFCAj48PN2/exNHRUR21VhQFjUbTYt/58+ej0+l44oknUBTFbBvvvvsuQ4YMoaCggNzcXH799VcAQkNDSU9PZ+jQocydO7dNN0sxFc+dKIpCeHg4RqMRo9FIUVER27dvVx/v27cv0PDho3FUOD4+HoDevXur29nb21NXV0d9fT3333+/Wp/RaOT06dMALFu2jBdffJHCwkI++uijVkesLemfRqPhvvvua7bEXmOdLi4uFBQUEBYWxgcffMBzzz1nsg+tqa+vJzMzU+3HxYsXcXZ25rXXXuPxxx/n5MmT/POf/2xzP4QQQhJvIYT4TVVVFS4uLvTp04fi4mKOHTvWYht3d3d+/PFHcnJyAKiurqauro6dO3eqF9m5uLjg7Oys7v/pp582a8PV1RU7Ozt2796tXrx4/vx5Bg8ezMKFC3n22WfJz883G2d9fb06Z3vv3r2MGTOGAQMG4OLios6V3r17tzr6bUpgYCBHjx7lu+++A+Dnn39WR9+bevjhh9UEdPHixWbr69+/P8OHD1fnhCuKQkFBgdrnoUOHAvDJJ5+o+zg7O5ucH3+7ffv2UV9fT2lpKd9//z2jRo3Czc0No9FIfX095eXlZGdnAw1TaOrr65k+fTr/8R//QX5+vsV9aDRp0qRmq5s0jow37UdCQkKb+yGEEDLVRAhhk6yx/N/kyZOJj4/Hy8uLUaNGERgY2GKbXr16kZiYyLJly7hx4wZOTk6kpqbSr1+/Zttt376dhQsX0rdvX8LCwhgwYAAAS5cuZfr06ezbt4/HH39cHVlOS0sjLi4OBwcH+vXr1+qId9++fTl16hS+vr4MGDBAvaDvk08+YfHixfz888+MGDGCnTt3mq1j0KBBJCQkMHv2bHVKyPr16xk5cmTbDloTe/bsYcmSJaxfv57a2lqeeuopvL29ef3115k5cyZDhw4lMDCQc+fOAfDHP/6RGTNm8OWXX7Jlyxaz87xHjRrFuHHjuHz5MvHx8Tg6OhISEsLw4cPx9PREq9Wi1+sBuHjxIvPnz1dHw998s+3TyzZv3swLL7yAl5cXdXV1hIaGEh8fz//+3/+befPm8c477zB+/Hh1+8cff5zY2Fh0Oh0rV66Ued5CCLM0rX0l2hP4+fkpjfP2xD2g6ZSSiW+2nGIic7xtlp+fHz3ptXr9+nU1GY+NjeXSpUu89957Vo5KdFc97fUhRE+m0WjyFEUxebMEGfEWQohOcODAAd58803q6uoYNmxYs6kJQggh7k2SeIueJWMrjFl65zIhOtmsWbPaPeUgICBAnQbSaPfu3Xh6erarXlv0xhtvtFgzfObMmbz66qtWikgIITqeJN5CCGGjsrKyrB1Cl3n11VclyRZC9HiyqonouWQJQSGEEELYEEm8hRBCCCGE6AKSeAshhBBCCNEFJPEWQgghhBCiC8jFlUIIm5R87HKH1hcZOKRD6+spgoOD+fbbbzusvn379vH6669z+vRpsrOz8fMzuZQtYWFhbNy40ezjlqqsrGTv3r0sXWp+5aK0tDQ2btzIV1991a62bhcVFcWUKVOYMWOGWtavXz+uX79+V/Vt2LCBVatWdVR4QggbJCPeQgjRBo23eO8pOjLpBtBqtfzjH/8gNDS0Q+s1p7Kykq1bt3ZJW51tw4YN1g5BCNHJJPEWPVtGz3hDFl1n6tSp+Pr64uHhwccffww0jGKuXr2agIAAMjMzycnJITg4GG9vb/z9/amurm5RT05ODl5eXgQFBREdHY1WqwWgrKyMsWPHotfr0ev1auJ76dIlQkND0el0aLVajhw5YjbGlJQUgoKC0Ov1zJw5Ux1hdXNzY82aNej1ejw9PSkuLgagoqKC8PBw9Ho9ixYtYtiwYVy5ckXtGzSMCoeFhTFjxgzc3d2ZM2cOjXc2zsvLY9y4cfj6+hIREcGlS5fMxvbYY48xatQoi471vn378Pf3Z+TIkWp/b926RXR0NAaDAS8vLz766COg4U6gEyZMUPv25ZdfAhATE0NpaSk6nY7o6GizbV27do3IyEhGjx7N4sWL1VvKN/YfICkpiaioKDU2rVaLt7f3XX+IiIuLU/uxZs0atdzUORYTE8ONGzfQ6XTMmTPnrtoTQtg+SbyFEKKJHTt2kJeXR25uLps3b+bq1avU1NSg1WrJysrC39+fWbNm8d5771FQUEBqaipOTk4t6pk/fz7x8fFkZmZib2+vlg8ePJhvvvmG/Px8EhMTWb58OQB79+4lIiICo9FIQUEBOp3OZHxXrlxh/fr1pKamkp+fj5+fH++88476+MCBA8nPz2fJkiVs3LgRgLVr1zJ+/Hjy8/OJjIzkwoULJus+fvw4mzZtoqioiO+//56jR49SW1vLsmXLSEpKIi8vjwULFnTYett1dXVkZ2ezadMm1q5dC8D27dsZMGAAOTk55OTksG3bNs6dO4ejoyPJycnk5+dz+PBhXn75ZRRFITY2lkceeQSj0UhcXJzZtrKzs3n77bcpLCyktLSUf/zjH63Gtm7dOg4dOkRBQQH79+83u110dDQ6nU79aZSSkkJJSQnZ2dkYjUby8vJIT08HTJ9jsbGxODk5YTQa2bNnT1sOoxCiG5E53kII0cTmzZtJTk4GoLy8nJKSEuzt7Zk+fToAZ86cwdXVFYPBAED//v1b1FFZWUl1dTXBwcEAPP300+r84traWl588UWMRiP29vacPXsWAIPBwIIFC6itrWXq1KlmE+9jx45RVFRESEgIAL/++itBQUHq49OmTQPA19dXTS4zMjLUPk2ePBkXFxeTdfv7+/PQQw8BoNPpKCsr4/777+fkyZOEh4cDDSPSrq6udz6QFmgaa1lZGdCQsJ44cYKkpCQAqqqqKCkp4aGHHmLVqlWkp6djZ2fHxYsXuXzZ8usA/P39GTFiBACzZ88mIyOj2dzs24WEhBAVFcWTTz6pxmlKXFxciznejf1ISUnBx8cHaBixLykpITQ01OQ59sADD1jcFyFE9yWJtxBC/CYtLY3U1FQyMzPp06cPYWFh3Lx5E0dHR3XUWlEUNBpNi33nz5/P8ePHefDBB1sdsXz33XcZMmQIBQUF1NfX4+joCEBoaCjp6ekcOHCAuXPnEh0dzTPPPNNif0VRCA8P5+9//7vJ+nv37g2Avb09dXV16j6WaNy36f6KouDh4UFmZqZFdZjT9PgcPHiw1Vi3bNlCREREs/0TEhKoqKggLy8PBwcH3NzcuHnzpsXt3/6cNf7etLxpffHx8WRlZXHgwAF0Oh1Go5FXXnmlRR/MURSFlStXsmjRombl5s4xIcS9QaaaCCHEb6qqqnBxcaFPnz4UFxdz7NixFtu4u7vz448/kpOTA0B1dTV1dXXs3LkTo9HIwYMHcXFxwdnZWd3/008/bdaGq6srdnZ27N69W71Y8/z58wwePJiFCxfy7LPPkp+fbzLGwMBAjh49ynfffQfAzz//rI6amzNmzBg+++wzoGEk9l//+pfFx2TUqFFUVFSoiXdtbS2nTp2yeP9GTY9PayIiIvjwww+pra0F4OzZs9TU1FBVVcXgwYNxcHDg8OHDnD9/HgBnZ2eTc+xvl52dzblz56ivrycxMZExY8YAMGTIEE6fPk19fb06Cg1QWlpKQEAA69atY+DAgZSXl1vch8Z+7NixQ51/f/HiRX766adWzzEHBwe130KInklGvEX3lLoSJr7Zsuxu9xU2xxrL/02ePJn4+Hi8vLwYNWoUgYGBLbbp1asXiYmJLFu2jBs3buDk5ERqamqzi/SgYa7ywoUL6du3L2FhYQwYMACApUuXMn36dPbt28fjjz9O3759gYaR0Li4OBwcHOjXrx+7du0yGeOgQYNISEhg9uzZ/PLLLwCsX7+ekSNHmu3XmjVrmD17NomJiYwbNw5XV1ecnZ0tOia9evUiKSmJ5cuXU1VVRV1dHX/+85/x8PAwuX1ycjLLli2joqKCP/zhD+h0Og4dOmRRWwDPPfccZWVl6PV6FEVh0KBBfPHFF8yZM4c//vGP+Pn5odPpcHd3B+CBBx4gJCQErVbL73//e7PzvIOCgoiJiaGwsJDQ0FAiIyMBiI2NZcqUKTz88MNotVo1UY6OjqakpARFUZgwYQLe3t4W9wFg0qRJnD59Wp0G1K9fP/72t7+1eo49//zzeHl5odfrZZ63ED2UxtKvILsrPz8/JTc319phiI5mLvHO2Apjljb/F/7n/69XSeJto/z8/OhJr9Xr16+ryXhsbCyXLl3ivffes0osv/zyC/b29tx3331kZmayZMkSjEajVWIRd6envT6E6Mk0Gk2eoigmb1IgI96i/W5PZBtHnjsyuTVVp7l2TC0haK1lBTvjWIhu4cCBA7z55pvU1dUxbNgwEhISrBbLhQsXePLJJ6mvr6dXr15s27bNarEIIcS9TBJvIYToBLNmzWLWrFntqiMgIECdTtJo9+7deHp6tqmeRx99lOPHj7crltu98MILHD16tFnZihUrmD9/foe20xaFhYXMnTu3WVnv3r3JysqyUkRC2Kiu+OZXvl02SRJv0bEsnWfd0W10RbttZYsxiW7FlhPGDz74wNohtODp6SlTaIQQNk1WNRFCCCGEEKILSOIthBBCCCFEF5DEW/QoyZNbrmdsqkwIIYQQoqtJ4i2EEEIIIUQXsGrirdFodmg0mp80Gs3JJmWvazSaixqNxvjbzxNNHlup0Wi+02g0ZzQaTYTpWoXVdMVFj22pz1pLCIqO8fqAjv0RJgUHB3dofdHR0bi7u+Pl5UVkZCSVlZUmtwsLC+uQdakrKyvZurX113paWhpTpkxpd1u3i4qKIikpqVnZ7TdSaosNGza0NyQh2k4WAuhS1h7xTgAmmyh/V1EU3W8/BwE0Gs1o4CnA47d9tmo0Gvsui7SrteeFYIsvorbcVfJu922PntKG6HSNt3jvKb799tsOrS88PJyTJ09y4sQJRo4cyZtvdu5yYpYk3t2FJN6iQzW+5zR972ntfagz36Nai6U9+UE3ZNXEW1GUdOD/Wbj5/wI+VRTlF0VRzgHfAf6dFpwQ4p40depUfH198fDw4OOPPwYaRjFXr15NQEAAmZmZ5OTkEBwcjLe3N/7+/lRXV7eoJycnBy8vL4KCgoiOjkar1QJQVlbG2LFj0ev16PV6NfG9dOkSoaGh6HQ6tFotR44cMRtjSkoKQUFB6PV6Zs6cqd7m3M3NjTVr1qDX6/H09KS4uBiAiooKwsPD0ev1LFq0iGHDhnHlyhW1b9AwKhwWFsaMGTNwd3dnzpw5NN7ZOC8vj3HjxuHr60tERASXLl0yG9ukSZO4776GlWoDAwP54YcfzG67b98+/P39GTlypNrfW7duER0djcFgwMvLi48++ghouBPohAkT1L59+eWXAMTExFBaWopOpyM6OtpsW9euXSMyMpLRo0ezePFi6uvrm/UfICkpiaioKDU2rVaLt7c3oaGhZuttTVxcnNqPNWvWqOWmzrGYmBhu3LiBTqdjzpw5d9WeEIBtJai2FIuNsPaItzkvajSaE79NRXH5rWwoUN5kmx9+K2tBo9E8r9FocjUaTW5FRUVnxyqE6EF27NhBXl4eubm5bN68matXr1JTU4NWqyUrKwt/f39mzZrFe++9R0FBAampqTg5ObWoZ/78+cTHx5OZmYm9/f98OTd48GC++eYb8vPzSUxMZPny5QDs3buXiIgIjEYjBQUF6HQ6k/FduXKF9evXk5qaSn5+Pn5+frzzzjvq4wMHDiQ/P58lS5awceNGANauXcv48ePJz88nMjKSCxcumKz7+PHjbNq0iaKiIr7//nuOHj1KbW0ty5YtIykpiby8PBYsWMCrr75q8bH8/e9/b/bxuro6srOz2bRpE2vXrgVg+/btDBgwgJycHHJycti2bRvnzp3D0dGR5ORk8vPzOXz4MC+//DKKohAbG8sjjzyC0WgkLi7ObFvZ2dm8/fbbFBYWUlpayj/+8Y9WY1+3bh2HDh2ioKCA/fv3m90uOjoanU6n/jRKSUmhpKSE7OxsjEYjeXl5pKenq8fl9nMsNjYWJycnjEYje/bsaTU2IUT3ZYuJ94fAI4AOuAS8/Vu5xsS2iqkKFEX5WFEUP0VR/AYNGtQ5UXY0Sz4V3s00jLZ+ldOVUldaL67ObtcWj7ewyObNm/H29iYwMJDy8nJKSkqwt7dn+vTpAJw5cwZXV1cMBgMA/fv3V0d4G1VWVlJdXa3On3766afVx2pra1m4cCGenp7MnDmToqIiAAwGAzt37uT111+nsLAQZ2dnk/EdO3aMoqIiQkJC0Ol0fPLJJ5w/f159fNq0aQD4+vpSVlYGQEZGBk899RQAkydPxsXFpUW9AP7+/jz00EPY2dmh0+koKyvjzJkznDx5kvDwcHQ6HevXr291FLvRG2+8wX333dfq6K2pWFNSUti1axc6nY6AgACuXr1KSUkJiqKwatUqvLy8mDhxIhcvXuTy5ct3jKNp30aMGIG9vT2zZ88mIyOj1e1DQkKIiopi27ZtrU4viouLw2g0qj+NUlJSSElJwcfHB71eT3FxMSUlJYDpc0wIcW+wuTtXKoqi/iXVaDTbgK9++/UH4OEmmz4E/NiFoQkheri0tDRSU1PJzMykT58+hIWFcfPmTRwdHdVRa0VR0GhajgPMnz+f48eP8+CDD7Y6Yvnuu+8yZMgQCgoKqK+vx9HREYDQ0FDS09M5cOAAc+fOJTo6mmeeeabF/oqiEB4ezt///neT9ffu3RsAe3t76urq1H0s0bhv0/0VRcHDw4PMzEyL6gD45JNP+Oqrr/iv//ov9Vg1PT4HDx5sNdYtW7YQEdH8+vmEhAQqKirIy8vDwcEBNzc3bt68aXFMtz9njb83LW9aX3x8PFlZWRw4cACdTofRaOSVV15p0QdzFEVh5cqVLFq0qFm5uXNMCHFvsLkRb41G49rk10igccWT/cBTGo2mt0ajGQ48CmR3dXxWYYujp7YYkwl3XMO7m/RDdI2qqipcXFzo06cPxcXFHDt2rMU27u7u/Pjjj+Tk5ABQXV1NXV0dO3fuxGg0cvDgQVxcXHB2dlb3//TTT5u14erqip2dHbt371ZHU8+fP8/gwYNZuHAhzz77LPn5+SZjDAwM5OjRo3z33XcA/Pzzz5w92/p5PmbMGD777DOgYST2X//6l8XHZNSoUVRUVKiJd21tLadOnTK7/X/+53/y1ltvsX//fvr06aOWNz0+rYmIiODDDz+ktrYWgLNnz1JTU0NVVRWDBw/GwcGBw4cPq6P8zs7OJufY3y47O5tz585RX19PYmIiY8aMAWDIkCGcPn2a+vp6kpOT1e1LS0sJCAhg3bp1DBw4kPLycov70NiPHTt2qPPvL168yE8//dTqOebg4KD2WwizevIiBPcAq454azSavwNhwECNRvMDsAYI02g0OhqmkZQBiwAURTml0Wg+A4qAOuAFRVF61vICQoj/8XpVlzc5efJk4uPj8fLyYtSoUQQGBrbYplevXiQmJrJs2TJu3LiBk5MTqampLZaR2759OwsXLqRv376EhYUxYEDDkoZLly5l+vTp7Nu3j8cff5y+ffsCDSOhcXFxODg40K9fP3bt2mUyxkGDBpGQkMDs2bP55ZdfAFi/fj0jR4402681a9Ywe/ZsEhMTGTduHK6urmanspjqb1JSEsuXL6eqqoq6ujr+/Oc/4+HhYXL7F198kV9++YXw8HCg4YNCfHy8RW0BPPfcc5SVlaHX61EUhUGDBvHFF18wZ84c/vjHP+Ln54dOp8Pd3R2ABx54gJCQELRaLb///e/NzvMOCgoiJiaGwsJCQkNDiYyMBCA2NpYpU6bw8MMPo9Vq1UQ5OjpaneIyYcIEvL29Le4DNFxkevr0aYKCgoCGizj/9re/tXqOPf/883h5eaHX62WetxA9lFUTb0VRZpso3t7K9m8Ab3ReREKIe1nv3r35+uuvW5Q3JmONDAaDydHwpjw8PDhx4gTQkNz5+fkB8Oijj6rlgLrc3rx585g3b55FcY4fP14dcW+qcZ40gJ+fH2lpaQAMGDCAQ4cOcd9995GZmcnhw4fVaR6NfQsLCyMsLEzd//3331f/r9Pp1AsD76RxJP5OGmODhgtCG2O3s7Njw4YNJpfWMzfdZe/eva22dXvfmpoxYwYzZsxoUX6niy+hYfrL7ZqeKytWrGDFihUttjF1jgG89dZbvPXWW3dsVwjRfdncHG8hhOgJDhw4wJtvvkldXR3Dhg0zmaR1lQsXLvDkk09SX19Pr1692LZtm9ViEUJYmUwZsSqbm+Mt7sDSuV2d9cKydCH+ttTTlsc6U1fetEj+8PV4s2bNwmg0cvLkSQ4cOMDdrLAUEBDQbKk6nU5HYWFhm+t59NFHOX78OAUFBeTk5KgrsrTHCy+80CK2nTt3trve9igsLGwRU0BAgFVjEsJm2dJ77T30nigj3qJjdPULKWMrjFnasmzyn1vfL3Wl6X2FsEFZWVnWDsGsDz74wNohtODp6dlsST8hxB3cQwmvrZARb9EjmVrN5I4rnAghhBCiY0ly34wk3qL9Mra2/P32so5ow8J2bCrp7oxjIYQQQohuSRJvW9bRnxJtaT6Xpdv1tE/K7TkWQgghBLT/eq/bB4Q64z1HBp1MksTblnR0gmqNBfW74oVmqo27abezP9jIHx0hhBBCNCEXVwohbFNHfzCa+GbH1sYb9sYAACAASURBVNdDBAcH8+2333ZYfa+99hpffvkldnZ2DB48mISEBB588MEW24WFhbFx40Z1ffO7VVlZyd69e1m61PwF02lpaWzcuJGvvvqqXW3dLioqiilTpjRbB7xfv34t1n231IYNG1i1alVHhSeEsEEy4m1r7oVpGR0duy3125ZiEZ2i8RbvPUVHJt3QcMfHEydOYDQamTJlCuvWrevQ+m9XWVnJ1q0949slUzcNEkL0LJJ4ix7lpS9yLSoTwpypU6fi6+uLh4cHH3/8MdAwirl69WoCAgLIzMwkJyeH4OBgvL298ff3p7q6ukU9OTk5eHl5ERQURHR0NFqtFmi4u+TYsWPR6/Xo9Xo18b106RKhoaHodDq0Wi1HjhwxG2NKSgpBQUHo9XpmzpypjrC6ubmxZs0a9Ho9np6eFBcXA1BRUUF4eDh6vZ5FixYxbNgwrly5ovYNGkaFw8LCmDFjBu7u7syZMwdFUQDIy8tj3Lhx+Pr6EhERwaVLl8zG1r9/f/X/NTU1aDQas9vu27cPf39/Ro4cqfb31q1bREdHYzAY8PLy4qOPPgIa7gg5YcIEtW9ffvklADExMZSWlqLT6YiOjjbb1rVr14iMjGT06NEsXryY+vr6Zv0HSEpKIioqSo1Nq9Xi7e1NaGio2XpbExcXp/ZjzZo1armpcywmJoYbN26g0+mYM2fOXbUnhLB9knjbup5ygWVb2fqFoF3RRnd5rnqYHTt2kJeXR25uLps3b+bq1avU1NSg1WrJysrC39+fWbNm8d5771FQUEBqaipOTk4t6pk/fz7x8fFkZmZib2+vlg8ePJhvvvmG/Px8EhMTWb58OdBw2/OIiAiMRiMFBQXodDqT8V25coX169eTmppKfn4+fn5+vPPOO+rjAwcOJD8/nyVLlrBx40YA1q5dy/jx48nPzycyMpILFy6YrPv48eNs2rSJoqIivv/+e44ePUptbS3Lli0jKSmJvLw8FixYwKuvvtrqMXz11Vd5+OGH2bNnT6sj3nV1dWRnZ7Np0ybWrl0LwPbt2xkwYAA5OTnk5OSwbds2zp07h6OjI8nJyeTn53P48GFefvllFEUhNjaWRx55BKPRSFxcnNm2srOzefvttyksLKS0tPSOt4Rft24dhw4doqCggP3795vdLjo6utkNexqlpKRQUlJCdnY2RqORvLw80tPTAdPnWGxsLE5OThiNRvbs2dNqbEIA8s13NyWJt+g4HXXRY1vbMEPW7RZ3Y/PmzXh7exMYGEh5eTklJSXY29szffp0AM6cOYOrq6t698f+/ftz333NL5eprKykurqa4OBgAJ5++mn1sdraWhYuXIinpyczZ86kqKgIAIPBwM6dO3n99dcpLCzE2dnZZHzHjh2jqKiIkJAQdDodn3zyCefPn1cfnzZtGgC+vr6UlZUBkJGRwVNPPQXA5MmTcXFxMVm3v78/Dz30EHZ2duh0OsrKyjhz5gwnT54kPDwcnU7H+vXr+eGHH1o9hm+88Qbl5eXMmTOH999/3+x2pmJNSUlh165d6l0nr169SklJCYqisGrVKry8vJg4cSIXL17k8uXLrcZxe99GjBiBvb09s2fPJiMjo9XtQ0JCiIqKYtu2ba1OL4qLi8NoNKo/jVJSUkhJScHHxwe9Xk9xcTElJSWA6XNMCKuRhQC6lCTetqo9LwRbfBFZGlNXJO+Wttsd2xDtkpaWRmpqKpmZmRQUFODj48PNmzdxdHRUR60VRTE5fWL+/PnodDqeeOIJdYqGKe+++y5DhgyhoKCA3Nxcfv31VwBCQ0NJT09n6NChzJ07l127dpncX1EUwsPD1USvqKiI7du3q4/37t0bAHt7e+rq6tR9LNG4b9P9FUXBw8NDba+wsJCUlBSL6nv66af5/PPPgebH506xbtmyRW3v3LlzTJo0iT179lBRUUFeXh5Go5EhQ4Zw8+ZNi+IAWjxnjb83LW9aX3x8POvXr6e8vBydTsfVq1dN9sEcRVFYuXKl2o/vvvuOZ5991uw5JkSHa3zPafre09r7UGe+R7UWS3vyg25IEm8hhPhNVVUVLi4u9OnTh+LiYo4dO9ZiG3d3d3788UdycnIAqK6upq6ujp07d2I0Gjl48CAuLi44Ozur+3/66afN2nB1dcXOzo7du3ero6nnz59n8ODBLFy4kGeffZb8/HyTMQYGBnL06FG+++47AH7++WfOnm39250xY8bw2WefAQ0jsf/6178sPiajRo2ioqKCzMxMoGHE/tSpU2a3bzp6u3//ftzd3QGaHZ/WRERE8OGHH1JbWwvA2bNnqampoaqqisGDB+Pg4MDhw4fVUX5nZ2eTc+xvl52dzblz56ivrycxMZExY8YAMGTIEE6fPk19fT3Jycnq9qWlpQQEBLBu3ToGDhxIeXm5xX1o7MeOHTvU+fcXL17kp59+avUcc3BwUPsthOiZZDlBW3CPzGvqseT56xxWWP5v8uTJxMfH4+XlxahRowgMDGyxTa9evUhMTGTZsmXcuHEDJycnUlNTm12kBw1zlRcuXEjfvn0JCwtjwIABACxdupTp06ezb98+Hn/8cfr27Qs0jLbHxcXh4OBAv379zI54Dxo0iISEBGbPns0vv/wCwPr16xk5cqTZfq1Zs4bZs2eTmJjIuHHjcHV1NTuVxVR/k5KSWL58OVVVVdTV1fHnP/8ZDw8Pk9vHxMRw5swZ7OzsGDZsGPHx8Ra10+i5556jrKwMvV6PoigMGjSIL774gjlz5vDHP/4RPz8/dDqdmtA/8MADhISEoNVq+f3vf292nndQUBAxMTEUFhYSGhpKZGQkALGxsUyZMoWHH34YrVarJsrR0dHqFJcJEybg7e3dpn5MmjSJ06dPExQUBDRcxPm3v/2t1XPs+eefx8vLC71eL/O8xd3L2Go7y6dmbIUx5pf6vBdJ4m0rLDk5TW1zp/0aX4C2ePI3fm1kjT8QnX08eshXYvea3r178/XXX7cov31dZoPBYHI0vCkPDw9OnDgBNCR3jetVP/roo2o5wJtvNpz/8+bNY968eRbFOX78eHXEvanGedIAfn5+pKWlATBgwAAOHTrEfffdR2ZmJocPH1aneTT2LSwsjLCwMHX/pnOzdTqdemHgnTROLbmTxtig4YLQxtjt7OzYsGGDyaX1Gkfdb7d3795W27q9b03NmDGj2Trcje508SVAQkJCi7Km58qKFStYsWJFi21MnWMAb731Fm+99dYd2xVCdF8y1USI1tjSKifWqk/clQMHDjRbGvCvf/2r1WK5cOECBoMBb29vli9fzrZt26wWixBC3MtkxLs7MDd6as1l6e5ixNgt5gBlE02sJGDNRLEzvpLr5P64xRygLPYPndqGaL9Zs2Yxa9asdtUREBCgTidptHv3bjw9PdtUz6OPPsrx48fbFcvtXnjhBY4ePdqsbMWKFcyfP79D22mLwsJC5s6d26ysd+/eZGVlWSkiITrB3Xz73VHt2soUlm5MEm/Ro8nNc0R3ZssJ4wcffGDtEFrw9PRstqSfEELYGplq0kXcYg5YO4RuR46ZEEIIIXoSSbxtUXumKnTSNIdmSXBPm0PcTeZxywcRIYS4x1l6x0dr3xmyo2P6bbue8D4oiXd3Y+kNZjprVQ1LF+JvSz1teawzdeVNi2TVEyGEENbQ1hvXdFb7dyrroWSOt7CYW8wByhzNPNjFL6TkyWeJ/M+RLcq405zujK0m9+0uesKnfUt5ftK2CwjvpHBeYYfWJ4QQ3V43THi7+wIDMuIteiRTF1XKhZaiK4WFhZGb2/5zrrKykq1b7+7N0dRa2NbUlcckLS2NKVOmtLut20VFRZGUlNSs7PabJ7WFrT1HQnS4bpjcdyZJvEW7JU8+2+L328s6og1L27GlpLszjoWwrsZbvHeVrky8FUWhvr7+rtrqSu05JrZGEm8h7i2SeAshRBNTp07F19cXDw8PPv74Y6BhRHP16tUEBASQmZlJTk4OwcHBeHt74+/vT3V1tcm69u3bh7+/PyNHjuTIkSNAQ+IeHR2NwWDAy8uLjz76CGi44+GECRPQ6/V4enry5ZdfAg23YC8tLUWn0xEdHW2ynUuXLhEaGtrshj0xMTHcuHEDnU7HnDlzAHjnnXfQarVotVo2bdoENNzt8rHHHmPp0qXo9XrKy8tZsmQJfn5+eHh4sGbNGrWdgwcP4u7uzpgxY1i+fLk6olxTU8OCBQswGAz4+PiosVvzmABcu3aNyMhIRo8ezeLFi9UPFU1HqJOSkoiKilJj02q1eHt7Exoaarbe1sTFxan9aHrsTJ1Xpp4jIUTPJom3Lbn96xhzX8/c7QWWnfF1z211mhzdtbRdC/tlqo27GlXu6OPR2cdCdIkdO3aQl5dHbm4umzdv5urVq9TU1KDVasnKysLf359Zs2bx3nvvUVBQQGpqKk5OTibrqqurIzs7m02bNrF27VoAtm/fzoABA8jJySEnJ4dt27Zx7tw5HB0dSU5OJj8/n8OHD/Pyyy+jKAqxsbE88sgjGI1G4uLiTLazd+9eIiIiMBqNFBQUoNPpiI2NxcnJCaPRyJ49e8jLy2Pnzp1kZWVx7Ngxtm3bpt5U58yZMzzzzDMcP36cYcOG8cYbb5Cbm8uJEyf47//+b06cOMHNmzdZtGgRX3/9NRkZGVRUVKjtv/HGG+pt7A8fPkx0dDQ1NTVWPSYA2dnZvP322xQWFlJaWnrH28CvW7eOQ4cOUVBQwP79+81uFx0djU6nU38apaSkUFJSQnZ2Nkajkby8PNLT0wHT59Xtz5EQFmvnQgst3p/a8p5j4Uok7fq215o3COxkknh3tttPCls9SRrjahqfrcZ6L5HnoMtt3rwZb29vAgMDKS8vp6SkBHt7e6ZPnw40JKmurq4YDAYA+vfvz333mb5Ofdq0aQD4+vpSVlYGNCRnu3btQqfTERAQwNWrVykpKUFRFFatWoWXlxcTJ07k4sWLXL582aKYDQYDO3fu5PXXX6ewsBBnZ+cW22RkZBAZGUnfvn3p168f06ZNU0echw0bRmBgoLrtZ599hl6vx8fHh1OnTlFUVERxcTEjRoxg+PDhAMyePVvdPiUlhdjYWHQ6HWFhYdy8eZMLFy5Y9ZgA+Pv7M2LECOzt7Zk9ezYZGSbunNtESEgIUVFRbNu2rdUpRXFxcRiNRvWn6XFISUnBx8cHvV5PcXExJSUlgOnzSgibc7fvOakrbef9ylbiMENWNbE1lt721Vq3jO0IHb0CSsZWmPznu9+/I3WX50CYlJaWRmpqKpmZmfTp00dNIh0dHbG3twca5kFrNJoW+86fP5/jx4/z4IMPcvDgQaDhduUA9vb21NXVqftv2bKFiIiIZvsnJCRQUVFBXl4eDg4OuLm5cfPmTYviDg0NJT09nQMHDjB37lyio6N55plnmm2jKIrZ/fv27av+/9y5c2zcuJGcnBxcXFyIiori5s2bre6vKAqff/45o0aNalZuzWMCtHieGn9vWt60vvj4eLKysjhw4AA6nQ6j0cgrr7zSog+tHYeVK1eyaNGiZuXmzishxL1HEm8hhE2yxvJ/VVVVuLi40KdPH4qLizl27FiLbdzd3fnxxx/JycnBYDBQXV2Nk5MTO3futKiNiIgIPvzwQ8aPH4+DgwNnz55l6NChVFVVMXjwYBwcHDh8+DDnz58HwNnZ2ewc8kbnz59n6NChLFy4kJqaGvLz83nmmWdwcHCgtrYWBwcHQkNDiYqKIiYmBkVRSE5OZvfu3S3qunbtGn379mXAgAFcvnyZr7/+mrCwMNzd3fn+++8pKyvDzc2NxMTEZn3asmULW7ZsQaPRcPz4cXx8fKx6TKBhqsm5c+cYNmwYiYmJPP/88wAMGTKE06dPM2rUKJKTk9VvCEpLSwkICCAgIIB//vOflJeXW9yHxn689tprzJkzh379+nHx4kUcHBxaPa+aPkdCiJ5Pppp0hfZ87dHJ85Btli0t7N/RX1tZ2kZ3ea56kMmTJ1NXV4eXlxevvfZas+kXjXr16kViYiLLli3D29ub8PDwNo1ePvfcc4wePRq9Xo9Wq2XRokXU1dUxZ84ccnNz8fPzY8+ePbi7uwPwwAMPEBISglarNXshYVpaGjqdDh8fHz7//HNWrFgBwPPPP4+Xlxdz5sxBr9cTFRWFv78/AQEBPPfcc/j4+LSoy9vbGx8fHzw8PFiwYAEhISEAODk5sXXrViZPnsyYMWMYMmQIAwYMAOC1116jtrYWLy8vtFotr732msXHo7OOCUBQUBAxMTFotVqGDx9OZGQkALGxsUyZMoXx48fj6uqqbh8dHY2npydarZbQ0FC8vb3b1I9Jkybx9NNPExQUhKenJzNmzKC6urrV86rpcyREm3TW/TO64u7Z9/BNdGTEW/RYsm63aKvevXvz9ddftyi/fv16s98NBoPJ0fCm0tLS1P8PHDhQnc9sZ2fHhg0bTC4jl5mZabKuvXv3ttrWvHnzmDdvXovyt956i7feekv9/S9/+Qt/+ctfmm3j5ubGyZMnm5UlJCSYbOfxxx+nuLgYRVF44YUX8PPzAxqS8saVSFrTlcckLCyMsLAwk4/NmDGDGTNmtCi/08WXYPrYND0/VqxYoX7wacrUeQUtnyMhRM8mI96iw3TYaiNtbEMI0TW2bduGTqfDw8ODqqqqFnOZhRC2w9L35K54X7VWu7ZIEm8b1Z4T0hZPZktjsqU/Ct2xDdGzFRYWNlvGrnEVkK7y0ksvYTQaKSoqYs+ePfTp06fL2jbH2sdECFvXnvffjtae9/ie8h4qibe1NJ0HdY/Ma+p22jNX7W7aMLWkY0fUK3oMT0/PZsvYGY1GsrKyrB2WVckxEfcMU3/XTZSZTFC7Yt62Ce1Olnvge5kk3lbmFnPAugH0wJO6K1n9+RNCCNE1rPV+aUvv07YUSyMLP5DYCkm8bYQlnwrv5iuaxsdb3a6VE7QzE8vkyWet9tXRndpV+32Xo9mW9MtUG6aOt6VlKvkGRQghOse9mnxbu/076UbJtyTe3YAtzmuyxZjuRpfc0lYIIUTP0ZV/+y2cSmJT1yl19LSW9pTZIFlOsLswdXdGS+/YaGt3drSkrDuzpePdnX30YcfWt2hJx9YnhBBCtJGMeHcimf8rxL0rLCyM3Nz2ryVfWVnJ1q2tfzhNS0tjypQp7W7rdl3ZB3OeeOIJKisrW93GkjhNHaOoqCiSkpLuKq4vvviCoqKiu9pXCIt0kxHcDmdpv7vp8ZHE2xa1ZwS4K0aPe+IIdU9oQ3SJW7dudWl77UlabUV7+nDw4EHuv//+Do6o/STxFlZh6bfG1v52uaNj6kHvoZJ4izaxqXlk3bjdnjJHvieaOnUqvr6+eHh48PHHHwPQr18/Vq9eTUBAAJmZmeTk5BAcHIy3tzf+/v5UV1ebrGvfvn34+/szcuRIjhw5AjQk7tHR0RgMBry8vNQ7Pl6/fp0JEyag1+vx9PTkyy+/BCAmJobS0lJ0Ol2rt0e/du0akZGRjB49msWLF1NfX6/G3igpKYmoqCg1Nq1Wi7e3N6GhoWbr7ao+XLp0idDQUHQ6HVqtVm3Lzc2NK1euUFZWxmOPPcbChQvx8PBg0qRJ3Lhxo1kd9fX1zJs3j7/+9a9m+2NOXl4e48aNw9fXl4iICC5dugQ03DTIYDDg7e3N9OnT+fnnn/n222/Zv38/0dHR6HQ6SktL29yeENZi0aILXdD+ncp6Kqsm3hqNZodGo/lJo9GcbFL2O41G841Goyn57V+XJo+t1Gg032k0mjMajSbCOlF3oLv4msQqd6IyE2fTNtoagy294FvooOelQ3XjC0m6mx07dpCXl0dubi6bN2/m6tWr1NTUoNVqycrKwt/fn1mzZvHee+9RUFBAamoqTk5OJuuqq6sjOzubTZs2sXbtWgC2b9/OgAEDyMnJIScnh23btnHu3DkcHR1JTk4mPz+fw4cP8/LLL6MoCrGxsTzyyCMYjUbi4uLMxp2dnc3bb79NYWEhpaWld7z9+bp16zh06BAFBQXs37/f7HZd1Ye9e/cSERGB0WikoKAAnU7XYpuSkhJeeOEFTp06xf3338/nn3/eLM45c+YwcuRI1q9fb7KNI0eONLvRTmO/a2trWbZsGUlJSeTl5bFgwQJeffVVAKZNm0ZOTg4FBQU89thjbN++neDgYP70pz8RFxeH0WjkkUceafVYC2Gr7qWE11ZY++LKBOB9YFeTshjgvxRFidVoNDG//f7vGo1mNPAU4AE8CKRqNJqRiqJ07fe+wia89EUu7071a1F2t/sK0Wjz5s0kJycDUF5eTklJCfb29kyfPh2AM2fO4OrqisFgAKB///5m65o2bRoAvr6+lJWVAZCSksKJEyfUucVVVVWUlJTw0EMPsWrVKtLT07Gzs+PixYtcvnzZ4rj9/f0ZMWIEALNnzyYjI4MZM2aY3T4kJISoqCiefPJJNU5r9sFgMLBgwQJqa2uZOnWqycR7+PDhannTeAAWLVrEk08+qSbMpowdO5avvvpK/b1x9P/MmTOcPHmS8PBwoGFE39XVFYCTJ0/y17/+lcrKSq5fv05ERPcf8xGiK0ly35xVE29FUdI1Go3bbcX/Cwj77f+fAGnAv/9W/qmiKL8A5zQazXeAP5DZFbEK825PZBsT4I5Mbk3V2VgW6dhhzXS47hCj+B9paWmkpqaSmZlJnz59CAsL4+bNmzg6OmJvbw+AoihoNJoW+86fP5/jx4/z4IMPcvDgQQB69+4NgL29PXV1der+W7ZsaZHAJSQkUFFRQV5eHg4ODri5uXHz5k2LY789psbfm5Y3rS8+Pp6srCwOHDiATqfDaDTyyiuvWK0PoaGhpKenc+DAAebOnUt0dDTPPPNMs20aY2mMp+lUk+DgYHWUvXHkvXGE/v/+3//batuKouDh4UFmZsu3k6ioKL744gu8vb1JSEggLS3Nov4IIYQp1h7xNmWIoiiXABRFuaTRaAb/Vj4UONZkux9+KxNC9ERWWP6vqqoKFxcX+vTpQ3FxMceOHWuxjbu7Oz/++CM5OTkYDAaqq6txcnJi586dFrURERHBhx9+yPjx43FwcODs2bMMHTqUqqoqBg8ejIODA4cPH+b8+fMAODs7m51D3lR2djbnzp1j2LBhJCYm8vzzzwMwZMgQTp8+zahRo0hOTsbZ2RmA0tJSAgICCAgI4J///Cfl5eVW7cP58+cZOnQoCxcupKamhvz8/BaJd2ueffZZ0tPTmTlzJsnJyURGRhIZGak+3lrCPGrUKCoqKsjMzCQoKIja2lrOnj2Lh4cH1dXVuLq6Ultby549exg6dKjFfRJCiNt1p4srWw4xgWJyQ43meY1Gk6vRaHIrKio6OazO09Ffz9j0vGoz2/W0r6jacyxE55s8eTJ1dXV4eXnx2muvERgY2GKbXr16kZiYyLJly/D29iY8PLxNI9PPPfcco0ePRq/Xo9VqWbRokTo/OTc3Fz8/P/bs2YO7uzsADzzwACEhIWi12lYvrgwKCiImJgatVsvw4cPVpDM2NpYpU6Ywfvx4dfoEQHR0NJ6enmi1WkJDQ/H29rZqH9LS0tDpdPj4+PD555+zYsUKi+Np9Je//AW9Xs/cuXPVi0st0atXL5KSkvj3f/93vL290el0fPvttwD8x3/8BwEBAYSHh6v9AXjqqaeIi4vDx8dHLq4UXa6913vdPjWzTe85Fq4wYun0z/a00R1XO7HFEe/LGo3G9bfRblfgp9/KfwAebrLdQ8CPpipQFOVj4GMAPz8/k8l5l8nYCmOWWrRp8uSzRP7nyLvazlxZm+Kc+Ob//J668rcTeswdY6HJi6tdLzQLmWrjbtrt6LtW3v4cdMixsOA5EB2nd+/efP311y3Kr1+/3ux3g8FgcjS8qaYjrAMHDlTnI9vZ2bFhwwY2bNjQYh9TUx2g4cLD1oSFhREWFmbysRkzZpic632niy+ha/swb9485s2b16K8sc2BAwdy8qR6HT6vvPKKyTgbp5fcztQxSkhIUP+v0+lIT09vsd+SJUtYsqTlty8hISGynODtUlc2fx+5V/SkfrchZ+nQfe8htjjivR9o/Os7D/iySflTGo2mt0ajGQ48CmRbIb72ucOnM6uPDnfBp8eOjt2WRodtKRYhhBCiS9jSyLMtxWKCVUe8NRrN32m4kHKgRqP5AVgDxAKfaTSaZ4ELwEwARVFOaTSaz4AioA54QVY0EULcSwoLC5k7d26zst69e5OVlWWliNquJ/RBCCHullVHvBVFma0oiquiKA6KojykKMp2RVGuKooyQVGUR3/79/812f4NRVEeURRllKIoLb8PtlXt+PTVU+Z5t5VNzUfv4E/PlrbRXZ4r0XU8PT0xGo3NfrpbwtoT+iCELbDJb74t3PdeuKbLHFucaiKEEEIIIUSPI4n3vayD73zYURc9trWNLiV3ixRCiJ7N0jsFd/T7gZXek7vTogg9gSTe1mDBi6s9J6Qtnsxtuavk3e7bHj2lDSGEEKKp9rz/drT2vMf3lPdQW1xO8N7QZNmde2VeU7fTjrlqd9VG49KBGVth8p/vvs7Gurr58lYfLP7/OrS+F+LHd2h9QgjRpUy9J5koe+mL3JZ3S27vvG1zywTeYSnF2+9s3aFtd1My4n2vs/Fld4TorsLCwsjNbf8ITWVlJVu3tv46TUtLY8qUKe1u63Zd2QdzTK0Vbk1RUVEkJSU1K+vXr99d12dr/ROtsNb7pS29T9tSLI0s/EBiKyTxthGWfIVyN1/RND7e6nZWOkFf+iLXal8dWdru3Y5mt6Vf7Rkx9/zE06L6TG0n7s6tW127iml7klZb0ZWJt6IobbprpbXda4l3t/9bdK8m39Zu/066UfItiXc3YIvzmmwxprvRJbe0Fd3K1KlT8fX1xcPDg48//hhoGNFcvXo1AQEBZGZmkpOTQ3BwMN7e3vj7+1NdXW2yrn379uHv78/IyJ1xYQAAIABJREFUkSM5cuQI0JC4R0dHYzAY8PLy4qOPPgIa7o45YcIE9Ho9np6efPllw73DYmJiKC0tRafTtXrL+GvXrhEZGcno0aNZvHixmnw2HY1NSkoiKipKjU2r1eLt7U1oaKjZeruqD5cuXSI0NBSdTodWq+XIkSPExMRw48YNdDodc+bMAeCdd95Bq9Wi1WrZtGkT0HB3y8cee4ylS5ei1+spLy9nyZIl+Pn54eHhwZo1a9R2Dh48iLu7O2PGjGH58uXqNwU1NTUsWLAAg8GAj4+PGntbxcXFqcelabumzitT/RPdQFf+7TczlcSSso5mcRsdvRxhe8pskMzx7iZuvzW7uTJL97WWe2HtTls63qLtduzYwe9+9ztu3LiBwWBg+vTp1NTUoNVqWbduHb/++ivu7u4kJiZiMBi4du0aTk5OJuuqq6sjOzubgwcPsnbtWlJTU9m+fTsDBgwgJyeHX375hZCQECZNmsTDDz9McnIy/fv358qVKwQGBvKnP/2J2NhYTp48idFobDXu7OxsioqKGDZsGJMnT+Yf//iHyVvFN1q3bh2HDh1i6NChVFZWmt2uq/qwd+9eIiIiePXVV7l16xY///wzY8eO5f3331f3y8vLY+fOnWRlZaEoCgEBAYwbNw4XFxfOnDnDzp071ZH1N954g9/97nfcunWLCRMmcOLECUaOHMmiRYtIT09n+PDhzJ49W23/jTfeYPz48ezYsYPKykr8/f2ZOHEiffv2bRFrdHQ069evb1GekpJCSUkJ2dnZKIrCn/70J9LT0wkNDTV5XsXGxjbrnxCi55MRbyGEaGLz5s14e3sTGBhIeXk5JSUl2NvbM336dADOnDmDq6srBoMBgP79+3PffabHMKZNmwaAr68vZWVlQENytmvXLnQ6HQEBAVy9epWSkhIURWHVqlV4eXkxceJELl68yOXLly2O29/fnxEjRmBvb8/s2bPJyMhodfuQkBCioqLYtm1bq9NnuqoPBoOBnTt38vrrr1NYWIizs3OLbTIyMoiMjKRv377069ePadOmqaPww4YNIzAwUN32s88+Q6/X4+Pjw6lTpygqKqK4uJgRI0YwfPhwgGaJd0pKCrGxseh0OsLCwrh58yYXLlwwGWtcXFyzGwA1rSMlJQUfHx/0ej3FxcWUlJQAps8r0UNZuizgnbbrJiO4bjEHOrbC3/p9x3q7yfG5nSTeNqg9I8BdMXrcI0eoe0Abov3S0tJITU0lMzOTgoICfHx8uHnzJo6Ojtjb2wMNc4j///buPW6Osrz/+PdKCJFztUKKQQwqJEKO8AAiNAVETD1BLP5qRc40kV+wFKo20eKBqkWNh4ocBKoCwk9QDOABRPiB1sopQCQgBwMBORVRawiImODVP3Y27LPP7O7s7sw99+x+3q/Xvp7de2fmvmZ2nplr773nHjMbM+9RRx2l2bNn601vetOGsokTJ0qSxo8fr/Xr12+Y/7TTTtuQtK1evVoHHnigLrzwQj355JO69dZbtWLFCk2aNEl/+MMfMsfeHFP9dWN54/LOOussffzjH9fDDz+s2bNn6ze/+U2p6zB37lz9+Mc/1uTJk3XYYYfp/PPPHzONu7ecv7FlevXq1Vq6dKmuvfZa3XHHHXrzm9+sP/zhD23nd3ddeumlG9bpl7/8pV7zmtekbpN2y1iyZMmGZaxatUrHHHNMy/0K6FaVfzXuJ/aqrGMWdDXBWNwkpj22TxBlDP+3Zs0avfjFL9amm26qe+65RzfeeOOYaaZNm6bHHntMt9xyi3bffXetXbtWm2yyib761a9mquONb3yjzjzzTO2///6aMGGC7rvvPk2ePFlr1qzRNttsowkTJui6667TQw89JEnaYostWvYhb3TzzTdr9erVesUrXqGLL75YCxYskCRNmjRJd999t6ZOnaply5ZtaEm+//77teeee2rPPffUd77zHT388MOlrsNDDz2kyZMn6+///u/1zDPP6LbbbtPhhx+uCRMmaN26dZowYYLmzp2rI488UosXL5a7a9myZbrgggvGLOupp57SZpttpq222kpPPPGErrzySu27776aNm2aHnjgAT344IOaMmWKLr744lHrdNppp+m0006Tmen222/XnDlzMm+T+jJOPvlkHXroodp888316KOPasKECW33q8b1q7RhPS5Gut7tuqeG6A9Ol8vWaPEuUw8/k5RyJ6qGOBuX2+p5lhh6fa9fmerN6XPJc/oqX0hSJfPmzdP69es1c+ZMnXzyyaO6LtRtvPHGuvjii/Xe975Xs2bN0hve8IauWi+PPfZY7bzzztp11101ffp0LVy4UOvXr9ehhx6q5cuXa2RkRBdeeKGmTZsmSfrzP/9z7b333po+fXrbiyv32msvLV68WNOnT9cOO+yg+fPnS5JOPfVUveUtb9H++++vbbfddsP073//+zVjxgxNnz5dc+fO1axZs0pdh+uvv16zZ8/WnDlzdOmll+qEE06QJC1YsEAzZ87UoYceql133VVHHnmk9thjD+2555469thjNWfOnDHLmjVrlubMmaNddtlFRx99tPbee29J0iabbKIzzjhD8+bN0z777KNJkyZpq622kiSdfPLJWrdunWbOnKnp06fr5JNPzrw96g488EC9613v0l577aUZM2bokEMO0dq1a9vuV43rB4RU1shiw34XS1q8ASAxceJEXXnllWPKn3766VGvd99999TW8EbXX3/9hucvfelLN/SPHjdunD75yU+mDiN3ww03pC7roosualvXvvvuq3333Tf1vUMOOST1Istvf/vbbZcphV2HI444QkccccSY8k996lP61Kc+teH1SSedpJNOOmnUNFOmTNGdd945quxrX/taaj377bef7rnnHrm7Fi1apJGR2s09Ntlkkw2js7STttzG/eOEE07Y8KWhUdp+JY1dP2DQDFNSnQUt3gHlfgFCzmKPDwD6dc4552j27NnaZZddtGbNGi1cuLDskBBaWveQvLuM5HWBJbpShTyGFm8AqIiVK1fqsMMOG1U2ceJE3XTTTSVF1L2y1+HEE0/UiSeeGKQuAGhGi3fE8v55Jva7RA5Dv69+tsWgGzdunNatW1d2GFGbMWPGqGHsVqxYUamkWxqMdQht3bp1GjeO0zVekPf1XqHutpx3HVUc7YT/5IjknaCGuCtjlRPEvLdPlbdFDKZNm6YLLriA5BtosG7dOl1wwQUbLlSN2k/OiL+LRRHdTLq50J2uJUOPriYFWzbvPs2/aqfRr5/+QsvpT7xsuT5/8EjH5aZNl3XeVnHqsuWj4itqOKC8vyTElPD28xmkGaYhmZYuXar3ve99Ouusszbc7hwYduPGjdO0adO0dOnSskPBEGjOWbqZT1JP8+at13UIhcR7GF2zRDrg38qOAhhlm222Sb1pCgBUUtZzLefkoUJXkwD66YM0KP28uxVTf/S8+5BlraMqnxUAILyirosKcffsYbimqxUSbwAAACAAEu9hxp0Puxf7Novpwp1rlmjGeTPKjgJAYC3/70OMn91Gx+NRPZasdwpuLGuzHpmPgzGdX5L14RiePxLvMsT0zwW0ElMSD2B4xTQCSojlVeXYW5U4I0PiXZLGflDD0q+pavrpq9ZLHfXnefQpr+LYpgAQWt4tulmX10u9acf1EONdt5234IbEQTyXkXgPuUHcqYfJyslvyXU6AChSlY9FZZ0vYzpPxxRLXT9fSMpA4o2od9Cyhfg1YlhHrgGAsnX7RaDT+bKoxpCyz9Nl199JlZJvEm+gR7H+UwMAihPy2F/F80ze3Vr6KYsRiXdF9DPmZep0JV0UUemxOzNus9LWhwtdAMSq5BFNpIytzFnj7CL2nuuNQJW7BsWKxBsAACAvWS847DBdVVpw8xbigtEykXhHqJ8W0yr2SS4b2wwAhlAFhwus8q/Guf9yX1Ek3hiLccbbY/sAwGjDelyMdL3LTtAHKVHOG4l3iaryM0lV4sxLjOtb5QtJAABADYk3AAAAEACJNwAAGB5p3UPy7jKS0wWWGDwk3gAAAEAAJN4AAADIJKaRwKp4ESeJNwAAyEfsXSxCdDPptn4MFRLvgjV/G4v121k9rvrfZfPuizbWGIQaUaSsz2DGeTNKqRdAdbU6LmY9nqRNV4VjURHng7LWO+s5pzm+Ey9bHk3OEEscrZB4A1XX6mYMzeWdXjeUjbpNcDc3e6hP27icdvOnxZQlzizLyrr8buroR4Cba4yat9XzIkV622tk1Ms+mvI/1Xyb8TG3HW/xP5h2e/INZf3uW90eV5qOZX3X2+W2jeJW7W1ijiK+iiLxHkb81AUAQLFi73aDUpB4BxD7zx5oL6YLSQAAKFI/5yPOZZ2ReAODJKaWk5hiAVC+si9s7KSfWGJajzwM2vpEpGXibWYnZXgsDBnsoIjlVt+xxFElQ7XNOPACiEHgY9GG43xDvWnH/q7PBx3WI63eqFUlzsi0a/F+v6TNJW3R5vFPRQVmZg+a2UozW2Fmy5Oyl5jZD83sF8nfFxdVPxC6i0nzyDJ5LRcAUH1px/UQ4123m3eoGqNy0i7xvsDdT3H3j7V6SLqs4Pj2c/fZ7j6SvF4s6Vp331HStcnrSoolMYolDvSIi3cAVEmFj0VlnS9jOk+HjiVLff18ISlDy8Tb3T/QaeYs0+TsIEnnJc/Pk3Rw4PoHUsw7KABA1RyqMa+hMbst60aXXwQ6ni8Lagwp+zxddv2dVCn57nhxpZlNNLN3mdkHzezD9UeA2FzS1WZ2q5ktSMomufvjkpT83SZAHD2Zsvh7ZYeAgsX6Tw0AKE7IY38VzzN5d2vppyxGWUY1uVy1lub1kp5peBRtb3ffVdJfS1pkZnOzzmhmC8xsuZktf/LJJ4uLsMoq/HNfaWLfZrHHB2B4xTCiSZb6ssbZTey91huDWOOqsCyJ93bu/rfu/ml3/2z9UXRg7v5Y8vdXkpZJ2kPSE2a2rSQlf3/VYt6z3X3E3Ue23nrrokMFoBd+5cn6aw+/ChWHbYsQ8trPBm1/zXrBYafpqtKCm7cQF4yWKUvi/VMzm1F4JA3MbDMz26L+XNKBku6UdIWkI5LJjlCtNR5A0WK6pXpZy8tD6NvGdztd3n1oY/wMYpf358Jn0Frerblc7I4MNmr1hpmtVK2f9UaSjjKzByQ9J8kkubvPLDCuSZKWmVk9xovc/Sozu0XSJWZ2jKRfSnpHgTEAAAAAuWnX4v0WSW9VrY/1q1VrdX5rQ3lh3P0Bd5+VPHZx908k5b9x99e7+47J398WGcewYlzOsRp/Cq3S9plxXvYfq0L93Js1pryny3veKhi0n/ARryodF/M0rOuN3rVLvE9UrV/1end/qPkRKL6BVpX+SVWJMy8xrm+Vr+AGAAA17RLvVZLmS/qv5C6SF5nZIjObY2ZZ+oYDAABEJZfbv/dQRz/TYXC07OPt7l+S9CVpwwgie0t6nWot4dtI2jJEgAAAAMAgaNtybTUzVRvH+yBJf6VaS3jhwwkCCGfQ+zpLw7GOaYZ1vQcSI5S8gFFdUFEtE28z+6GkGyUtUm00k0+6+27uPs/dPxYqQAAAUA2xd7EI0c2k2/oxXNq1eD+g2nCCOyaPV5vZS4NEhdJx4V57g7Z91t59atkhFG4Y1jHNsK43MsqxRTjYcTGy1u5BOx+gWC0Tb3df6O6vlXSwpOsl7Sbp62Z2q5mdFyg+AJ385Azpo1ullze9HtXtoD5f47z1svq8jc/rr+t/P7pVbXnN8zf/rdfbOF39eXPsyfSjpmueph5zc1nadmhcj8bl12NPW8fmevIqa46l1+maPoMx69e8nPrztH2kuR5p7GfVap5Wn0HKMtvVl6mevKbrRdr2LmL5RWoXe9o+0ymm5nlSjjWpx4VWr1stp3HaVvt2XadjYJYYOtXbi26Xk1e9eWgXQwzxVVSW0Umek/R7Sc8mz7eTtGuRQaFY/NQ1vPJu/cy6vBhbXWOMKQZsFyAfsXe7QTna9fH+vJndJOlxSadI2kLSlyVNdXeu1gEAYBCEaHXPKo9YYlofoEm7Fu/Vql1YubW77+/u/+Lu33f33wWKDQAQi36SmbR5s5blHUse+lmfvNexrDoA9KRd4v0TSX+SNMvMdm1+BIpvIMVyIUYscVRJ7Nssz58s+10WP58CaNTriCKhjiX1eurH+cZ6O909OI/1SKu3LDF9LoOm5Q10JC2XdJekJ5PX1vCeS9q/qKAAAEBARV+cmte8ef+ygL7E3hgVo3Yt3v8kaY1qF1V+VdJb3X2/5EHSDUSgl4t3YryhSt4xxbiOMUnbPlnL+qkD7eX9ucT4GdBKimHXbjjBz7v7PpKOl/RySdea2SVmNjtYdAAAAAXJ+4sAI5mgk47DCbr7akmXS7pa0h6Sdio6KAAA0KCK4yb3E3O7Mb3zqgMoQbvhBF9pZh9MhhT8mKSfSZrm7pcEiw6F4dt292LfZrHHB2B4lX2r9qz1ZY2zm9irfKFirHFVWbsW71WS/o+kqyTdIGl7Sf/XzE4ys5NCBAcAAFAlWS845MLE4dQu8T5F0jLVhhTcXLUb6DQ+AAyLED/n5l1HjD9Bd3vb6NB15P1TfoyfQew6fQb10TpC7EtlCTQOOf27UYZ2F1d+1N0/1uoRMkgAkHobpaHbESD6GVki7xEoYhztpVOc7eqIcZSNGMS0Xao8YkqMMQHN2vXxXtBp5izToHr4+as9tg8AjDasx8VhXW/0rt0NdBab2a/bvG+STpB0dr4hAQAAAIOnXeL9I0lv7TD/D3OMBUAgM86boZVlB5GDYfhpOe/PqspdCQYZ2xsYDi0Tb3c/KmQgAAAARTvxsuWa/6KxZZ8/eCTXOrIsL+96Eb+ON9ABAAAA0D8Sb2DATVn8vbJD2CBrLGnTxbQeQyfrsG1Z581a1k8s/dSbdx3darWM5qEBy9qOMWgxTOKY40QVh1PEQOuYeJvZ+BCBAMjf2rtPzW1ZefVBzRpT3tNlmTfEEIF5T9fP5xKyX3GIumIcfnHYxH7zmLR6Q8bCKChod3Fl3Soz+5akr7r7z4sOCEB3Wt2MYdm8+6SGg3z99SlTr9GH7z1g9HzJdM3Lqr+ef9VOOmXqNVo2VZrfON1ly7Vs3n2a31RH/f3m6UbV0zDdKZK0eqdR04+JJ63s3gPGlM2XdMrUazYs7xRJy6ZqVH1pyzslKf5w0zJPyVimG58Ys92ap5t/1U5jt1eb6erljdM1fwbNZfOv2mnUNk6rp759Gj/TetmG6Rum27AfNMWdVlaPp/kzbV6X+jab/9pJY7Zjr2X1z3DDdpS0rGm6bspS9/kbn5Dq8zTM265sQ0xpZQ2fc9r2bixr3C/SPpfm7dO8vNTt2KRxf2q3vU+RdOLdDf9TzceaNpqPTZnnaVDfFs2xj4qpxXTd1NfvzW66Xc6o6UtO0tvFzE2Aepelq8lMSfdJOtfMbjSzBWa2ZcFxoUB840Y/QtzopR8hbhLTb9mM82bUkrAM8/YTX1ZZ5+0n5m7qTts+ZZW1ijFtulZlzfOnlaVJW16r6Yr4dSXr9kG62Fv/UY6Oibe7r3X3c9z9dZI+IOkjkh43s/PM7NWFRwgAGGhFJXPdJMe9xhSijqz6iRlAGJn6eJvZ28xsmaR/l/RZSa+U9B1J3y84PgAAAGAgZOlq8gtJB0n6jLvPcffPufsT7v4tSVcVGx6AbsT0k2VMsQAoX9kXNnbSTywxrUceBm19YpKpj7e7H+PuP21+w93/oYCYAESAAy+AGMQ0AkqI5VXl2FuVOGOTZVSTT5pZc9kaScvd/fL8QwIAAAAGT5YW7xdJmq1al5NfqDbKyUskHWNmXygwNgAdDFoLCoDBFtuxiFZthJalxfvVkvZ39/WSZGZnSrpa0hskrSwwNgAAAGBgZGnxnixps4bXm0l6mbs/L+m5QqJC4fi23b3Yt1ns8QEYXjFcWJmlvqxxdhN7r/XGINa4qixLi/enJa0ws+slmaS5qvX73kzSNQXGBgAAAAyMti3eVruq8mpJr5N0WfLYx93Pdfdn3P39AWIEULIQtwfOu44Yb2nc7W2jQ9fRy62184gFL8j7c+EzaI3+3ShD2xZvd3czu8zdd5PECCYAAABAj7L08b7RzHYvPBIAAABggGXp472fpPeY2YOSnlGtn7e7+8wiAwMAAAAGSZbE+68LjwIAAAAYcB27mrj7Q5JertpY3g9J+n2W+QAMprV3n5qprCx5xJJ1Hfspy1pv1un6We+y5q2KYVhHAGF0TKDN7COS/lnSkqRogqSvFxlUh3jmmdm9ZrbKzBaXFQcAAADQjSwt1/MlvU21/t1y98ckbVFkUK2Y2XhJp6vW/WVnSX9nZjuXEQuA8EK0PMbe2l22YVjHWDE04AsYThFVlSXx/qO7uySXpOTGOWXZQ9Iqd3/A3f8o6RuSDioxHgAAACATq+XUbSYwe5+kHSW9QdK/STpa0kXuflrx4Y2J5RBJ89z92OT1YZL2dPfjm6ZbIGmBJG2//fa7PfTQQ6FDlb58Zvg6AQAAULPwuFKqNbNb3X0k7b2Oo5q4+1Ize4OkpyRNlfRhd/9hzjFmZSllY745uPvZks6WpJGRkfbfLAAAAIAAsgwnqCTRLivZbvSIaiOs1G0n6bGSYgEAAAAyyzKqydvN7BdmtsbMnjKztWb2VIjgUtwiaUcz28HMNpb0TklXlBQLAAAAkFmWFu9PS3qru99ddDCduPt6Mzte0g8kjZf0FXe/q+SwAAAAgI6yJN5PxJB017n79yV9v+w4AAAAgG5kSbyXm9nFki6T9Fy90N2/XVhUAAAAwIDJknhvqdpt4g9sKHNJJN4AAABARlmGEzwqRCAAAADAIMsyqslOZnatmd2ZvJ5pZv9SfGgAAADA4Mhyy/hzJC2RtE6S3P0O1YbxAwAAAJBRlsR7U3e/ualsfRHBAAAAAIMqS+L9azN7lZJbs5vZIZIeLzQqAAAAYMBkGdVkkaSzJU0zs0clrZZ0aKFRAQAAAAMmy6gmD0g6wMw2kzTO3dcWHxYAAAAwWLK0eEuS3P2ZIgMBAAAABlmWPt4AAAAA+kTiDQAAAATQMvE2s7e3e4QMEgBQrtNvn5rrvFnL8o4lD/2sT97rWFYdAHrTrsX7rW0ebyk+NAAYYAuPKzuC7hUVc9py8yhrfK+fsjQh6+gk6/J6XW4v8wJI1TLxdvej2jyODhkkgIjEfjLOI5Zekr52yU9zWasYy0qIypw3bdv0WpYWT7/La15mXvtG3v8zWfaxduuYZXkx/Z8DFZWpj7eZvdnMPmBmH64/ig4MQGSaTrpl/fxcaL39tLI2Of32qYVPl3Xelnqct6fuDUldwT+/HJdHlwsA/eqYeJvZWZL+VtJ7JZmkd0h6RcFxAQAAAAMlS4v369z9cEn/4+4fk7SXpJcXGxaA3MT08zB9S6sp71b1fj7fvPehvGMpqqtT3vXnPV0sqhYvhk6WxPvZ5O/vzexlktZJ2qG4kACEkvdIDGXVW5URMkLElPc2CxELXjBoI8AAGC1L4v1dM/szSZ+RdJukByV9o8igABQsx769Zem7f3PWOnosy02GfsZd1Z+133LWfucFKzvBDLbPl7AvAwiv4y3j3f1fk6eXmtl3Jb3I3dcUGxYAAAAwWDom3mY2XtKbJU2pT29mcvfPFRsaAAAAMDg6Jt6SviPpD5JWSvpTseEAAAAAgylLH+/t3P3t7v4Rd/9Y/VF4ZAAqIegFgx36wabWkTJP2+mKuotiJyFGcsm4vLafVdabxfRR/9CJabtUebSTGGMCmmRJvK80swMLjwRAz0KPPFH2hVrd1p/XOuZxsWXje/1MF2Ib9Lq8vOoq+8LKEHV0vdweksuy95Wu9ZD8d/1lEShJlq4mN0paZmbjVBtK0CS5u29ZaGQAAADAAMmSeH9WtZvmrHR3LzgeAAAAYCBl6WryC0l3knQDAAAAvcuSeD8u6XozW2JmJ9UfRQcGoHxV7jsLoDz8XwPpsiTeqyVdK2ljSVs0PABUUYwXGpU0esfQyntElqx1oL0QI+XkMW038t6HQuy7QIHa9vFObp6zubu/P1A8AAAAwEBq2+Lt7s9L2jVQLAAAAMDAyjKqyQozu0LSNyU9Uy90928XFhUAICqLzto/13mzluUdSx76WZ+817HvOr58b26xAOgsS+L9Ekm/kdT4n+eSSLwBAKi6mPpD5xFLTOsDNOl4caW7H5XyODpEcADyc/rtU7s+IXVs6cqwvE71ltaaxsk5HdsFOWj3f82IJxhmHVu8zWwnSWdKmuTu081spqS3ufvHC48OQCZZfzJOnU8aNW+7ZdWnbzyp9vKTeFc/cX/53o71pU2X9n43sRTVnSDrtms1Xa+fQdttk3HajvMk2zHrenUSQ9eTtO1dxPKL1LaOlC9a0XctWXic9OUzRxWlxpwyHVC2LMMJniNpiWq3i5e73yHpnUUGBQAAAAyaLIn3pu5+c1PZ+iKCAVCSYeheMAzrmGZY13sQ8Vm+oIixzIEAsiTevzazV6l2QaXM7BDV7mYJAAAAIKMso5osknS2pGlm9qhqd7J8d6FRAQAAAAMmy6gmD7j7AZK2ljTN3fdx9wcLjwxAFKo8AkHW2EOsY4hYyv6syq4f/Ynp/wUYVFlGNZko6W8kTZG0kZlJktz9lEIjA9C/GPs35t03s591jHH7AAAGVpY+3pdLOki1CyqfaXgUwsw+amaPmtmK5PGmhveWmNkqM7vXzN5YVAzAGBVM0LpulYpgHWlJy1kEnykA4AVZ+nhv5+7zCo9ktM+7+9LGAjPbWbVhDHeR9DJJ15jZTu7+fODYAAAAgK5lafH+qZnNKDySzg6S9A13f87dV0taJWmPkmMChkLpN/mIYHl5CHFDmH7q6OVmOnnEghfk/bnwGQBxaZl4m9mdZnaHpH0k3ZZ077jDzFYm5UU6PqnrK2b24qRssqSHG6Z5JCkDEIN6twbnXdeBAAASwklEQVTG1y0f2xYh5LWfsb9iiLTrajJZ0uwiKjWzayT9RcpbH1Lt9vT/qtq44f8q6bOSjpZkKdN7i+UvkLRAkrbffvscIu4Bt6oFAABAg3aJ92p3f6iISpPhCTsys3MkfTd5+Yiklze8vZ2kx1os/2zVxh7XyMhIanIOAEBlVLFVOO8Rh7KWARFrl3hvY2YntXrT3T9XQDwys23dvX5nzPmS7kyeXyHpIjP7nGoXV+4oqflW9gAAAECU2iXe4yVtrvQuHkX6tJnNVq0byYOSFkqSu99lZpdI+rlqQxsuYkQTAAAAVEW7xPvxMm6S4+6HtXnvE5I+ETAcAADQwum3T9WiOfeWHUZHZcVZle2DcNoNJxi6pRsAAAAYWO0S79cHiwIAAAAYcC0Tb3f/bchAAABA9Zx++9TK1dFpefX386o363JCbMusYoplkGS5cyWAAZR2UO33QNvtySrLdHkva1hOJo3rOSzrjOpiH8WwMPfBHuZ6ZGTEly9fXk7l3EBncMR8Q6T6OLbN8TWOb/vlM7sb77a+rH7GyM1jGQCqodPxp/m9xrLGY1jz8SLP40hzne2O6fX3+z32d7ucmM41McXSq5LOP2Z2q7uPpL1HizeAsUiWAeQl6/GEG+S8IPb1jj2+iJF4AwAAAAGQeAMAAAABkHgDAAAAAZB4AwAAAAGQeAMAAAABkHgDAAAAAZB4AwAAAAGQeAMAgOGT91jU/YxXjqFB4g0AAAAEQOI9rPjG3b3Yt1ns8QEYXlW5K2XWOMtqLUflkXgDAAAAAZB4AwAAAAGQeAMAAAABkHgDAIDhxMgmCIzEGxgkeR7M+13WwuM4uQDDqNX/fa8XKYY6jjTX0029ea5HDMfNmD6XAUPiDQAABl9ZiWKVE9Qqxx4pEm8AAAAgABLvYcQ3WAAAilWlriUIhsQbAAAACIDEGwAA5CP2Vt6y76BJ6/bQI/EGAAAAAiDxBgAAAAIg8QYAAAACIPEOKfa+XbHHBwBAv0L08469r/ugqsD2JPEGAAAAAiDxxlgV+MZYKrYPAIw2rMfFYV1v9IzEGwAAAAiAxBsAAAAIgMQbAAAgL8N2YWVR6zEo26cJiTcAAAAQAIk3UGXD1rICoNo4FmHIkXgDAAAAAZB4AwAAAAGQeAMAAKB7dB3qGol3GWLZUWOJo0rYZgAw2LLeUr6s28yj0ki8AQAAgABIvAEAAIAASkm8zewdZnaXmf3JzEaa3ltiZqvM7F4ze2ND+W5mtjJ574tmZuEjBwAAAHpTVov3nZLeLunHjYVmtrOkd0raRdI8SWeY2fjk7TMlLZC0Y/KYFyxaAAAAoE+lJN7ufre735vy1kGSvuHuz7n7akmrJO1hZttK2tLdb3B3l3S+pIMDhjx8uMijPbYPAIw2rMfFYV1v9CS2Pt6TJT3c8PqRpGxy8ry5HAAAAKiEjYpasJldI+kvUt76kLtf3mq2lDJvU96q7gWqdUvR9ttv3yFSAAAAoHiFJd7ufkAPsz0i6eUNr7eT9FhSvl1Keau6z5Z0tiSNjIy0TNABAACAUGLranKFpHea2UQz20G1iyhvdvfHJa01s9cmo5kcLqlVqzkAAAAQnbKGE5xvZo9I2kvS98zsB5Lk7ndJukTSzyVdJWmRuz+fzHacpHNVu+DyfklXBg8cAAAA6FFZo5osc/ft3H2iu09y9zc2vPcJd3+Vu0919ysbype7+/TkveOT0U2qrSpXQlclzrzEuL4hblcMAAAKFVtXEwAAAGAgkXgDAAAAAZB4F4muAAAAoBfDmkNkXe+Kbh8SbwAAACAAEm+gVxX9tg0A6EPIY38VzzP9xJx1IIEKDzhA4l22GHaUdjHEEF8ZQvzUNQQHGAAYKGUde8s+5pddfycVOk+SeJcllh0iljgAAIjZsCbdjULHkqW+CiXdEok30FqIf9zGOurP86g34oMOAKAH/SSYef86i56ReAMAAAABkHgDAAAAAZB4AwAAAAGQeIdA/6hqC93XGwCAstAfvFAk3gAAAEAAG5UdwMBr/vYX67fBtBE1Yo11mPAZAABC6fWcE9O5KqZYUtDiDQAAAARA4g0AAIBsYrruKfLW7TQk3gAAAEAAJN4AAABAACTeyK6CP+kMHD4DAMAwq/h5kMQbAAAACIDEGwAAYJCktQqHbCmueKt0kUi8Q+lmJ4zxrlFljO89SPXkUQcHMgAYbmUn1P3oJ/a0e41UFIk3AAAAEACJd1Xk8U2xbAuPq/a39ayKXp9B214AAAwJEm8AAAAgABJvoJ2q9P8ucnkAACAXJN4AAABAACTeMaCFstr4/AAAQAYk3gAAAEAAJN4AAABAACTeAAAAQAAk3rEb1hEvyoozplFMqvJZAQDCq/J9Maoce59IvAEAAIAASLxj009raFW+LeYde0zrHVMsAAAgKiTeMck76Y6p20SMhrUbDwAAKAWJd8wGJTEchlb8rOjfDQDoV94NcJxzgiHxBgAAAAIg8QYAAAACIPEGAABAMejGMgqJd9XEemFltzHE3t88luUCAFAUzl3BkXijO4M8UkrIejnYAQDKUD//xHSuHaJzIok3AAAAEACJNwAAABBAKYm3mb3DzO4ysz+Z2UhD+RQze9bMViSPsxre283MVprZKjP7oplZGbEDAAAAvSirxftOSW+X9OOU9+5399nJ4z0N5WdKWiBpx+Qxr/gwIxFj36cYY+rFoKwHAGA4xDCgAnpWSuLt7ne7+71ZpzezbSVt6e43uLtLOl/SwYUFWIYsO3Qv/2xlX0TRzsLj4rq4o0rLBwAAlRNjH+8dzOx2M/uRmf1lUjZZ0iMN0zySlKUyswVmttzMlj/55JNFxgoAAABkslFRCzazayT9RcpbH3L3y1vM9rik7d39N2a2m6TLzGwXSWn9ub1V3e5+tqSzJWlkZKTldAAAAAMlpl9cY4olEoUl3u5+QA/zPCfpueT5rWZ2v6SdVGvh3q5h0u0kPZZHnNHqZ2eNcUfPGlOr7jRfPjPfeLLUW8U6AABo1M/5N2/99E8fkHNoVF1NzGxrMxufPH+lahdRPuDuj0taa2avTUYzOVxSq1ZzlCXEBR8D8o8HAEChYr3Tdch6I1TWcILzzewRSXtJ+p6Z/SB5a66kO8zsZ5K+Jek97v7b5L3jJJ0raZWk+yVdGThsAAAAoGeFdTVpx92XSVqWUn6ppEtbzLNc0vSCQwMAAAAKEVVXEwAAAGBQkXgDAAAAAZB4AwAAAAGQeCNfXB39ghhjAgCAIXRLQ+INAAAABFDKqCYYMM3faov4lluVVu5mVYgRAAAEQYs3AAAAEACJN6qJ284CAICKIfEGAAAAAiDxBgAAAAIg8QYAAAACIPEGAAAAAiDxBgAAAAIg8QYAAAACIPEGAAAAAiDxBgAAAAIg8QYAAAACIPEGAAAAAiDxxuDi1vAAACAiJN4AAABAACTeAAAAQAAk3gAAAEAAJN4AAABAACTeAAAAQAAk3gAAAEAAJN4YPGnDCDK0IAAAKBmJNwYTyTcAAIgMiTcAAAAQAIk3AAAAEACJNwAAABAAiTcAAAAQAIk3BhsXVAIAgEiQeAMAAAABkHgDAAAAAZB4AwAAAAGQeAMAAAABkHgDAAAAAZB4AwAAAAGQeAMAAAABkHgDAAAAAZi7lx1DoczsSUkPlVD1SyX9uoR6UU3sL8iKfQVZsa+gG+wv+XmFu2+d9sbAJ95lMbPl7j5SdhyoBvYXZMW+gqzYV9AN9pcw6GoCAAAABEDiDQAAAARA4l2cs8sOAJXC/oKs2FeQFfsKusH+EgB9vAEAAIAAaPEGAAAAAiDxLoCZzTOze81slZktLjsehGdmLzez68zsbjO7y8xOSMpfYmY/NLNfJH9f3DDPkmSfudfM3thQvpuZrUze+6KZWRnrhGKZ2Xgzu93Mvpu8Zl/BGGb2Z2b2LTO7Jzm+7MW+glbM7MTkHHSnmf0/M3sR+0u5SLxzZmbjJZ0u6a8l7Szp78xs53KjQgnWS/ond3+NpNdKWpTsB4slXevuO0q6Nnmt5L13StpF0jxJZyT7kiSdKWmBpB2Tx7yQK4JgTpB0d8Nr9hWk+XdJV7n7NEmzVNtn2FcwhplNlvQPkkbcfbqk8artD+wvJSLxzt8ekla5+wPu/kdJ35B0UMkxITB3f9zdb0uer1Xt5DhZtX3hvGSy8yQdnDw/SNI33P05d18taZWkPcxsW0lbuvsNXrsg4/yGeTAgzGw7SW+WdG5DMfsKRjGzLSXNlfQfkuTuf3T334l9Ba1tJGkTM9tI0qaSHhP7S6lIvPM3WdLDDa8fScowpMxsiqQ5km6SNMndH5dqybmkbZLJWu03k5PnzeUYLF+Q9AFJf2ooY19Bs1dKelLSV5NuSeea2WZiX0EKd39U0lJJv5T0uKQ17n612F9KReKdv7R+TwwdM6TMbHNJl0r6R3d/qt2kKWXephwDwszeIulX7n5r1llSythXhsNGknaVdKa7z5H0jJJuAi2wrwyxpO/2QZJ2kPQySZuZ2bvbzZJSxv6SMxLv/D0i6eUNr7dT7acdDBkzm6Ba0n2hu387KX4i+dlOyd9fJeWt9ptHkufN5Rgce0t6m5k9qFrXtP3N7OtiX8FYj0h6xN1vSl5/S7VEnH0FaQ6QtNrdn3T3dZK+Lel1Yn8pFYl3/m6RtKOZ7WBmG6t2ocIVJceEwJIrvv9D0t3u/rmGt66QdETy/AhJlzeUv9PMJprZDqpdvHJz8jPgWjN7bbLMwxvmwQBw9yXuvp27T1HtePH/3f3dYl9BE3f/b0kPm9nUpOj1kn4u9hWk+6Wk15rZpsnn/HrVrjdifynRRmUHMGjcfb2ZHS/pB6pdQfwVd7+r5LAQ3t6SDpO00sxWJGUflHSqpEvM7BjVDorvkCR3v8vMLlHtJLpe0iJ3fz6Z7zhJX5O0iaQrkwcGH/sK0rxX0oVJw84Dko5SrRGNfQWjuPtNZvYtSbep9vnfrtrdKTcX+0tpuHMlAAAAEABdTQAAAIAASLwBAACAAEi8AQAAgABIvAEAAIAASLwBAACAAEi8ASAnZvZ00+sjzexLZcXTEMc0M1uR3Gb8VU3vfbDh+RQzuzN8hNklMT5bH6azXcxm9hkz+28ze1/YKAEgHYk3AETOzMb3uYiDJV3u7nPc/f6m9z6YNkMszCztfhP3u/vsTvO6+/slnZV/VADQGxJvAAjAzF5hZtea2R3J3+2T8q+Z2SEN0z2d/N3XzK4zs4tUuxHTZmb2PTP7mZndaWZ/m1LHbDO7MaljmZm92MzeJOkfJR1rZtc1TX+qpE2S1vALk+LxZnaOmd1lZleb2SbJtK8ys6vM7FYz+08zm9a0rHFm9gsz27rh9Soze6mZbW1ml5rZLclj72SaPczsp0lL/E/rd2RMfin4ppl9R9LVGTZvaswAEBsSbwDITz2JXZF0hTil4b0vSTrf3WdKulDSFzMsbw9JH3L3nSXNk/SYu89y9+mSrkqZ/nxJ/5zUsVLSR9z9+6q1+n7e3fdrnNjdF0t61t1nu/uhSfGOkk53910k/U7S3yTlZ0t6r7vvJul9ks5oWtafJH1dUn05B0j6mbv/WtK/J/Xvnizv3GSaeyTNdfc5kj4s6ZMNi9xL0hHuvn+G7dQqZgCICreMB4D8PNvYBcLMjpQ0krzcS9Lbk+cXSPp0huXd7O6rk+crJS01s09J+q67/2fjhGa2laQ/c/cfJUXnSfpmD+uw2t1XJM9vlTTFzDaX9DpJ3zSz+nQTU+b9iqTLJX1B0tGSvpqUHyBp54Z5tzSzLSRtJek8M9tRkkua0LCsH7r7b3uNOeN8ABAUiTcAlMOTv+uV/Ppotcx044Zpntkwsft9ZrabpDdJ+jczu9rdG1vU8/Jcw/PnJW2SxPe7Tv2q3f1hM3vCzPaXtKdeaP0eJ2kvd3+2cXozO03Sde4+38ymSLq+4e1nlF1azAAQHbqaAEAYP5X0zuT5oZJ+kjx/UNJuyfODNLrVdwMze5mk37v71yUtlbRr4/vuvkbS/5jZXyZFh0n6kTpbZ2apdTYs+ylJq83sHUksZmazWkx+rmpdTi5x9+eTsqslHd+wLvUEfitJjybPj8wQKwBUGok3AITxD5KOMrM7VEuKT0jKz5H0V2Z2s2qtxK1aemdIujnpO/4hSR9PmeYISZ9J6pit0X3MWzlb0h0NF1e2cqikY8zsZ5LuUu1LQporJG2uF7qZSLV1H0ku+vy5pPck5Z9WrfX+vyT1O3ILAETP3L3zVAAAZGBmI6pdSPmXHSfubflTVOvjPj3j9B+V9LS7Ly0iHgDoBi3eAIBcmNliSZdKWlJgNc9L2qp+A50O8XxG0rvVXX9xACgMLd4AAABAALR4AwAAAAGQeAMAAAABkHgDAAAAAZB4AwAAAAGQeAMAAAABkHgDAAAAAfwvqvSB7Dr7e50AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plotter = ar.Plotter('clustered_results.json')\n", "plotter.plot_operation('heat_storage', 'Heat', ylabel='Thermal energy [MWh]',\n", " file_name='heat_storage', plot_single_period_with_index=7,\n", " show_plot=True)\n", "plotter.plot_operation('heat_bus', 'Heat', ylabel='Thermal energy [MWh]',\n", " file_name='heat_bus', scale_to_hourly_resolution=True, \n", " show_plot=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Two-stage model run\n", "\n", "The last part of this example shows the possibility of dividing the original problem into two levels to reduce computation time and enable the fast generation of several high-quality design solution candidates.\n", "The developers of *aristopy* have published a comparable method in [this paper](https://doi.org/10.1115/IMECE2019-11519).
\n", "In the first optimization stage, a simplified problem is considered, and a design candidate is generated. The simplification is achieved by the aggregation of time series data and the relaxation of binary operation variables. In the second step, the design candidate's objective function value is determined for the original problem by considering the full-scale model.\n", "\n", "Building a large optimization model in Pyomo can take a considerable time. Therefore Pyomo offers the possibility to create so-called persistent solvers (only for Gurobi and CPLEX). This solver instance is created only once, and the model is added via its persistent interface. Later, this model can be solved various times without the time-consuming building phase. The flag \"declare_persistent\" must be set to True during model declaration to exploit these persistent models in *aristopy*. Minor changes can be added to the persistent solver at a later stage. More information about the persistent solver interface of Pyomo can be found [here](https://pyomo.readthedocs.io/en/stable/advanced_topics/persistent_solvers.html)." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "# Construct (declare) a persistent model of the original (full scale) instance\n", "original_model.declare_model(use_clustered_data=False, declare_persistent=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the following steps, the cluster function is called for the energy system model (not the original/full-scale model!), and the model is declared with aggregated data. Then the binary operating variables (ON/OFF) are relaxed so that they can take on values between zero and one. The existence variables remain binary." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# Cluster time series data, declare the model and relax the integrality of the\n", "# binary operation variables\n", "es.cluster(number_of_typical_periods=20,\n", " number_of_time_steps_per_period=24//hpts)\n", "es.declare_model(use_clustered_data=True)\n", "es.relax_integrality(include_time_dependent=True,\n", " include_existence=False, include_modules=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Subsequently, several optimization problems are iteratively solved, and the results are stored in a pandas DataFrame for further comparison. In the first step, the problem is solved with clustered data (model is not declared again!). The configuration (existence and capacity of the components) is imported into the full-scale problem. Now, this original problem is solved with a fixed design as a pure dispatch model. \n", "In the last step, an integer cut constraint is introduced in the aggregated model. Thus, the current design solution (the combination of binary variables) is excluded from the solution space, and another design solution must be generated in the next model run." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# Create a number of integer-cuts\n", "nbr_of_icc = 5\n", "\n", "# Store some results in a DataFrame to compare solutions\n", "results = pd.DataFrame(index=range(nbr_of_icc), columns=[\n", " 'Obj. value [Mio.€]', 'Nbr. of engines [-]', \n", " 'Capacity storage [MWh]', 'Capacity boiler [MW]', \n", " '1st stage time [s]', '2nd stage time [s]'])\n", "\n", "for icc in range(nbr_of_icc):\n", "\n", " # Run optimization with clustered data\n", " es.optimize(use_clustered_data=True, declare_model=False,\n", " tee=False, results_file=f'1st_stage_results_{icc}.json')\n", "\n", " # Export the configuration to a DataFrame and store it in an Excel-File\n", " config = es.export_component_configuration(\n", " write_to_excel=True, file_name=f'1st_stage_config_{icc}.xlsx')\n", "\n", " # Import the optimal configuration and fix design variables\n", " original_model.import_component_configuration(config)\n", "\n", " # Run the already declared persistent, full scale model\n", " original_model.optimize(declare_model=False, tee=False,\n", " results_file=f'2nd_stage_results_{icc}.json')\n", "\n", " # Reset variables to their original (unfixed) values\n", " original_model.reset_component_variables()\n", "\n", " # Add an integer-cut constraint for the gas engines to the aggregated model\n", " # => Exclude previously found optimal design from the solution space\n", " es.add_design_integer_cut_constraint(which_instances=['gas_engine'])\n", " \n", " \n", " results['Obj. value [Mio.€]'].loc[icc] = original_model.run_info['lower_bound'] / 1e6 \n", " results['Nbr. of engines [-]'].loc[icc] = sum(comp.block.BI_EX.value \n", " for comp in es.components.values() \n", " if comp.group_name == 'gas_engine')\n", " results['Capacity storage [MWh]'].loc[icc] = config['heat_storage'].loc['CAP']\n", " results['Capacity boiler [MW]'].loc[icc] = config['gas_boiler'].loc['CAP']\n", " results['1st stage time [s]'].loc[icc] = es.run_info['model_solve_time']\n", " results['2nd stage time [s]'].loc[icc] = original_model.run_info['model_solve_time']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The following summary of the results shows that a single iteration can be performed much faster by splitting it into two optimization levels. The detected solutions are comparable to the globally optimal solution of the original problem (see above). In addition, further design candidates are evaluated, and a deeper understanding of the present model is gained." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Obj. value [Mio.€]Nbr. of engines [-]Capacity storage [MWh]Capacity boiler [MW]1st stage time [s]2nd stage time [s]
0-164.2023100161.5011
1-166.424210018104
2-163.984150142036
3-172.91210200.501
4-166.6535150122.5194
\n", "
" ], "text/plain": [ " Obj. value [Mio.€] Nbr. of engines [-] Capacity storage [MWh] \\\n", "0 -164.202 3 100 \n", "1 -166.424 2 100 \n", "2 -163.98 4 150 \n", "3 -172.912 1 0 \n", "4 -166.653 5 150 \n", "\n", " Capacity boiler [MW] 1st stage time [s] 2nd stage time [s] \n", "0 161.5 0 11 \n", "1 181 0 4 \n", "2 142 0 36 \n", "3 200.5 0 1 \n", "4 122.5 1 94 " ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# print the results on the screen\n", "results" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.7.1" } }, "nbformat": 4, "nbformat_minor": 4 }