{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Maintaining voltage setpoints via PandaModels.jl\n", "### PandaModels.jl: Interfacing PowerModels with pandapower\n", "\n", "This tutorial describes how to run the optimization for maintaining voltage setpoints via [PandaModels.jl](https://e2niee.github.io/PandaModels.jl/dev/).\n", "Maintaining voltage setpoits (MVSP) is an optimization problem which is exclusively defined in [PandaModels.jl](https://e2niee.github.io/PandaModels.jl/dev/) and\n", "needs the extra user defined parameters from pandapower.\n", "\n", "\n", "The general mathematical model of MVSP is defined as follows:\n", "\n", "\\begin{align}\n", "& \\underset{\\mathcal{X} = [q, ...]}{\\text{minimize}}\n", "& & \\sum_{i\\in \\mathcal{BI}} [v_i - setpoint\\_v]^2 \\\\\n", "& \\text{subject to}\n", "& & g(\\mathcal{X})=0 \\\\\n", "& & & h(\\mathcal{X}) \\leq 0\n", "\\end{align}\n", "\n", "where $v_{i}$ is the voltage variable of bus $i$ in $\\mathcal{BI}$ which denotes the set of buses located at the DSO-TSO interfaces. The $g(\\mathcal{X})$ and $h(\\mathcal{X})$, denote equality and inequality constraints, respectively. The $\\mathcal{X}$ denotes the set of variables decisions, such as reactive power, $q$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Let's get started\n", "\n", "So here is an example of how it works. First, we create cigre grid with pv and wind DERs(distribution energy resource) from pandapower's network database." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "import pandapower as pp\n", "import pandapower.networks as nw\n", "from copy import deepcopy\n", "\n", "net = nw.create_cigre_network_mv(with_der=\"pv_wind\")" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "then we need to run powerflow to get the initial values:\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "net.sgen.p_mw = net.sgen.p_mw * 8\n", "net.sgen.sn_mva = net.sgen.sn_mva * 8\n", "pp.runpp(net)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's have a look at the grid we created with pandapower plotting module:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandapower.plotting as plot\n", "%matplotlib inline\n", "plot.simple_plot(net)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "let's keep a copy of the net for further comparision:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "net_org = deepcopy(net)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "Although VD is not a function of PowerModels and is exclusively modeled in Pandamodels, PandaModels similar to PowerModels follows the data structures from [InfrastructureModels.jl](https://github.com/lanl-ansi/InfrastructureModels.jl).\n", " In this data structure DERs are not defined separately unlike pandapower,\n", " then the uncontrollable load and sgens are converted to load and controllable elements are converted to the generator.\n", "\n", "Accordingly, we need to set loads as uncontrollable elements and set DERs (sgens) as controllable elements." ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "net.load['controllable'] = False\n", "net.sgen['controllable'] = True" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "now, lets set the optimization boundaries:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "# lower and upper bounds for buses\n", "net.bus[\"max_vm_pu\"] = 1.1\n", "net.bus[\"min_vm_pu\"] = 0.9\n", "\n", "# lower and upper bounds for external grid\n", "net.ext_grid[\"max_q_mvar\"] = 10000.0\n", "net.ext_grid[\"min_q_mvar\"] = -10000.0\n", "net.ext_grid[\"max_p_mw\"] = 10000.0\n", "net.ext_grid[\"min_p_mw\"] = -10000.0" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "in VD we need to keep the active power value for DER and generators constant to the calculated value from power flow.\n" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "# lower and upper bounds for DERs\n", "net.sgen[\"max_p_mw\"] = net.sgen.p_mw.values\n", "net.sgen[\"min_p_mw\"] = net.sgen.p_mw.values\n", "net.sgen[\"max_q_mvar\"] = net.sgen.p_mw.values * 0.328\n", "net.sgen[\"min_q_mvar\"] = -net.sgen.p_mw.values * 0.328\n", "\n", "# lower and upper bounds for generators\n", "net.gen[\"max_p_mw\"] = net.gen.p_mw.values\n", "net.gen[\"min_p_mw\"] = net.gen.p_mw.values\n", "net.gen[\"max_q_mvar\"] = 10000.0\n", "net.gen[\"min_q_mvar\"] = -10000.0" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "Let's set a high upper bound for line and transformers to avoid congestion issue:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "# lower and upper bounds for lines\n", "net.trafo[\"max_loading_percent\"] = 500.0\n", "net.line[\"max_loading_percent\"] = 500.0" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "I also we could set costs for sgens, gens and external grids in order to not get warnings during data correctness in julia side." ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "for idx in net.sgen.index:\n", " pp.create_poly_cost(net, idx, \"sgen\", 1.0)\n", "for idx in net.gen.index:\n", " pp.create_poly_cost(net, idx, \"gen\", 1.0)\n", "for idx in net.ext_grid.index:\n", " pp.create_poly_cost(net, idx, \"ext_grid\", 1.0)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "Finally, lets add our user defined parameter \"setpoint_v\". at first we need to add extra column called \"pm_param/setpoint_v\" in bus data,\n", "then we set values for buses contain DERs(sgens):" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "net.bus[\"pm_param/setpoint_v\"] = None\n", "net.bus[\"pm_param/setpoint_v\"].loc[net.sgen.bus] = 0.99" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now lets run an MVSP through PandaModels and look at the results (Note that the first time the function is called, Julia is started in the background, which may take some time):" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Cannot be performed due to [WinError 3] - Can't find file python39.dll\n" ] } ], "source": [ "try:\n", " pp.runpm_vstab(net)\n", "except Exception as err:\n", " print(err)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "Also, there more parameters and options that you can add as input while calling the Optimization Problem from PandaModles:\n", "\n", "| parameter | description | type | default |\n", "| :--- | :--- | :---: | :--- |\n", "| correct_pm_network_data | checks if network data is correct. If not tries to correct it | bool | True |\n", "| silence | Suppresses information and warning messages output by PowerModels | bool | True |\n", "| pm_model | PowerModels.jl model to use | str | \"ACPPowerModel\" |\n", "| pm_solver | \"main\" solver| str | \"ipopt\" |\n", "| pm_mip_solver | mixed integer solver| str | \"cbc\" |\n", "| pm_nl_solver | nonlinear solver| str | \"ipopt\" |\n", "| pm_tol | default desired convergence tolerance for solver to use | float | 1e-8 |\n", "| pm_log_level | solver log level in power models | int | 0 |\n", "| delete_buffer_file | If True, the .json file used by PandaModels will be deleted after optimization. | bool | True |\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "lets check the result values for voltage and reactive power at buses contains DERs before and after VD:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "3 1.039473\n", "4 1.038293\n", "5 1.037487\n", "6 1.036603\n", "8 1.053060\n", "9 1.052446\n", "10 1.051725\n", "11 1.051589\n", "7 1.075642\n", "Name: vm_pu, dtype: float64" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# results from power flow\n", "net_org.res_bus.vm_pu[net_org.sgen.bus]" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3 NaN\n", "4 NaN\n", "5 NaN\n", "6 NaN\n", "8 NaN\n", "9 NaN\n", "10 NaN\n", "11 NaN\n", "7 NaN\n", "Name: vm_pu, dtype: float64" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# results from VD\n", "net.res_bus.vm_pu[net.sgen.bus]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "as exected the results are close to the defined setpoints, and as we set the active power constants we expect to get different results from power flow for reactive power:\n" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "0 0.0\n", "1 0.0\n", "2 0.0\n", "3 0.0\n", "4 0.0\n", "5 0.0\n", "6 0.0\n", "7 0.0\n", "8 0.0\n", "Name: q_mvar, dtype: float64" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# results from normal power flow\n", "net_org.res_sgen.q_mvar" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "0 NaN\n", "1 NaN\n", "2 NaN\n", "3 NaN\n", "4 NaN\n", "5 NaN\n", "6 NaN\n", "7 NaN\n", "8 NaN\n", "Name: q_mvar, dtype: float64" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# results from MVSP\n", "net.res_sgen.q_mvar\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.6" } }, "nbformat": 4, "nbformat_minor": 2 }