diff --git a/state-estimation-assignment/State Estimation Assignment with Solutions.ipynb b/state-estimation-assignment/State Estimation Assignment with Solutions.ipynb index a86957b..5962dcf 100644 --- a/state-estimation-assignment/State Estimation Assignment with Solutions.ipynb +++ b/state-estimation-assignment/State Estimation Assignment with Solutions.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "id": "a727ce38", "metadata": {}, @@ -28,7 +27,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "9cd12445", "metadata": {}, @@ -70,7 +68,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "50065790", "metadata": {}, @@ -145,7 +142,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "0c2bad59", "metadata": {}, @@ -491,7 +487,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "0234cab7", "metadata": {}, @@ -518,7 +513,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "940d48be", "metadata": {}, @@ -618,19 +612,13 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "2b013fa7", "metadata": {}, "source": [ "# Assignment 3: Initialize the sensors\n", "\n", - "In this assignment we will perform a state estimation based on three voltage sensors that only measure the voltage. \n", - "If you look closely to the data, you'll notice that the number of measurements (3) is not larger than or equal to the number of unknowns (6). \n", - "So the system is not *fully observable* and you might expect the state estimation to fail. \n", - "However, the linear state estimation algorithm will assume the voltage angles (3) to be zero if no value is given. \n", - "In other words, the mathematical core will give us a faulty result, without any warning! \n", - "To prevent this, we need an observability check, which is complex, but will be added to the validation functions in the future.\n", + "In this assignment we will try to perform a state estimation based on three voltage sensors that only measure the voltage. However, because the number of measurements (3) is lower than the number of unknowns (6), the system is not *fully observable*. This should result in an error.\n", "\n", "- initialize the voltage sensors\n", "- extend the input data set, with the voltage sensors\n", @@ -643,7 +631,18 @@ "execution_count": 6, "id": "88034903", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not enough measurements available for state estimation.\n", + "\n", + "Try validate_input_data() or validate_batch_data() to validate your data.\n", + "\n" + ] + } + ], "source": [ "# Initialize 3 symmetric voltage sensors, each connected to a different node\n", "sym_voltage_sensor = initialize_array(DatasetType.input, ComponentType.sym_voltage_sensor, 3)\n", @@ -662,6 +661,51 @@ "model = PowerGridModel(input_data)\n", "\n", "# Run the (iterative linear) state estimation\n", + "try:\n", + " se_output_data = model.calculate_state_estimation(\n", + " symmetric=True,\n", + " error_tolerance=1e-8,\n", + " max_iterations=20,\n", + " calculation_method=CalculationMethod.iterative_linear)\n", + "except Exception as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "id": "70cb5b3c", + "metadata": {}, + "source": [ + "# Assignment 4: Add voltage angle measurements\n", + "\n", + "Because the previous result gave an error, we will now add voltage angle measurements. We will alter the `input_data` and construct a new Model\n", + "\n", + "- initialize the voltage sensors again\n", + "- extend the input data set, with the voltage sensors including the voltage angle\n", + "- construct a new model with the new input data\n", + "- run the state estimation calculation" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c9a7953f", + "metadata": {}, + "outputs": [], + "source": [ + "# Set the voltage angle in the voltage sensor data\n", + "sym_voltage_sensor[\"u_angle_measured\"] = pf_output_data[ComponentType.node][\"u_angle\"]\n", + "\n", + "# Add the sensors to the input data\n", + "input_data[ComponentType.sym_voltage_sensor] = sym_voltage_sensor\n", + "\n", + "# Validate the input data\n", + "assert_valid_input_data(input_data, calculation_type=CalculationType.state_estimation, symmetric=True)\n", + "\n", + "# Create a power grid model\n", + "model = PowerGridModel(input_data)\n", + "\n", + "# Run the (iterative linear) state estimation\n", "se_output_data = model.calculate_state_estimation(\n", " symmetric=True, \n", " error_tolerance=1e-8, \n", @@ -670,12 +714,11 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "f4736cc1", "metadata": {}, "source": [ - "# Assignment 4: Compare the results between the loadflow and state estimation\n", + "# Assignment 5: Compare the results between the loadflow and state estimation\n", "\n", "For all nodes:\n", "- print the difference in `u` between `se_output_data` and `pf_output_data`\n", @@ -686,12 +729,12 @@ "- print the difference in `q_from` between `se_output_data` and `pf_output_data`\n", "- print the difference in `q_to` between `se_output_data` and `pf_output_data`\n", "\n", - "You should see that while the voltages match quite precisely (in the order of microvolts), the *p* and *q* are way off (in the order of megawatts / mega VARs). This is as expected, because we used voltage angles of 0.0." + "You should see that both the voltages and the *p* and *q* match quite precisely. If you use rounded values as input, there might be a little deviation, but it's rather small compared to the absolute value of *p* and *q*" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "a8d298d5", "metadata": { "scrolled": true @@ -702,12 +745,12 @@ "output_type": "stream", "text": [ "-------------- nodes --------------\n", - "delta_u: [-4.95101631e-07 4.55753252e-07 -3.82213329e-07]\n", + "delta_u: [-4.95099812e-07 4.55753252e-07 -3.82213329e-07]\n", "-------------- lines --------------\n", - "delta_p_from: [-8728680.30456089 -3024647.99628876]\n", - "delta_p_to: [8266130.33127038 2959493.85797146]\n", - "delta_q_from: [10436736.61039324 3714027.04294619]\n", - "delta_q_to: [-10806776.58902305 -3766150.35360264]\n" + "delta_p_from: [-0.02546052 0.01986547]\n", + "delta_p_to: [ 0.02106787 -0.01858635]\n", + "delta_q_from: [-0.02036185 0.01583978]\n", + "delta_q_to: [ 0.01685044 -0.01481901]\n" ] } ], @@ -725,87 +768,13 @@ ] }, { - "attachments": {}, - "cell_type": "markdown", - "id": "8db14616", - "metadata": {}, - "source": [ - "# Assignment 5: Add voltage angle measurements\n", - "\n", - "Now we will update the model by adding voltage angles to the voltage sensors.\n", - "We could alter the `input_data` and construct a new Model, but for the purpose of this workshop (and efficiency) we'll supply the voltage angles as `update_data`, which could potentially be a *batch* calculation in other usecases.\n", - "\n", - "- initialize an update voltage sensor array\n", - "- create an update dataset\n", - "- perform a state estimation, using the update dataset\n", - "- compare the results (as in assignment 4)\n", - "\n", - "You should see that the voltages match quite precisely (in the order of microvolts), the *p* and *q* do too (in the order of 0.01 watts / VARs), because we used the exact voltage angles from the power flow calculation." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "baa25a03", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-------------- nodes --------------\n", - "delta_u: [[-4.95103450e-07 4.55753252e-07 -3.82213329e-07]]\n", - "-------------- lines --------------\n", - "delta_p_from: [[-0.02546053 0.01986549]]\n", - "delta_p_to: [[ 0.02106792 -0.01858632]]\n", - "delta_q_from: [[-0.02036191 0.01583975]]\n", - "delta_q_to: [[ 0.01685042 -0.01481904]]\n" - ] - } - ], - "source": [ - "# Initialize a voltage sensor update array for 3 sensors\n", - "update_sym_voltage_sensor = initialize_array(DatasetType.update, ComponentType.sym_voltage_sensor, 3)\n", - "update_sym_voltage_sensor[\"id\"] = [9, 10, 11] # Use the same IDs as the original sensors\n", - "update_sym_voltage_sensor[\"u_angle_measured\"] = pf_output_data[ComponentType.node][\"u_angle\"]\n", - "\n", - "# Create an update dataset \n", - "update_data = {\n", - " ComponentType.sym_voltage_sensor: update_sym_voltage_sensor\n", - "}\n", - "\n", - "# Validate the update data\n", - "assert_valid_batch_data(input_data, update_data, calculation_type=CalculationType.state_estimation, symmetric=True)\n", - "\n", - "# Run the (iterative linear) state estimation\n", - "se_output_data_u_angle = model.calculate_state_estimation(\n", - " update_data = update_data,\n", - " symmetric=True,\n", - " error_tolerance=1e-8, \n", - " max_iterations=20, \n", - " calculation_method=CalculationMethod.iterative_linear)\n", - "\n", - "# Print the delta u for all nodes (se_output_data_u_angle - pf_output_data)\n", - "print(\"-------------- nodes --------------\")\n", - "print(\"delta_u:\", se_output_data_u_angle[ComponentType.node][\"u\"] - pf_output_data[ComponentType.node][\"u\"])\n", - "\n", - "# Print the delta p and q for all lines (se_output_data_u_angle - pf_output_data)\n", - "print(\"-------------- lines --------------\")\n", - "print(\"delta_p_from:\", se_output_data_u_angle[ComponentType.line][\"p_from\"] - pf_output_data[ComponentType.line][\"p_from\"])\n", - "print(\"delta_p_to:\", se_output_data_u_angle[ComponentType.line][\"p_to\"] - pf_output_data[ComponentType.line][\"p_to\"])\n", - "print(\"delta_q_from:\", se_output_data_u_angle[ComponentType.line][\"q_from\"] - pf_output_data[ComponentType.line][\"q_from\"])\n", - "print(\"delta_q_to:\", se_output_data_u_angle[ComponentType.line][\"q_to\"] - pf_output_data[ComponentType.line][\"q_to\"])" - ] - }, - { - "attachments": {}, "cell_type": "markdown", "id": "7b054f55", "metadata": {}, "source": [ "# Assignment 6: Add power sensors to the model\n", "\n", - "In common power grids most voltage sensors only measure the voltage magnitude; not the angle. In this assigment we will again use the `input_data` of assignment 3 (with unknown voltage angles) and we will connect power sensors to the model.\n", + "In common power grids most voltage sensors only measure the voltage magnitude; not the angle. In this assigment we will again use the `input_data` of assignment 3 and we will connect power sensors to the model.\n", "\n", "In our network it would be possible to connect power sensors to the lines, the loads and the source. To assign realistic measurement values to the power sensors we can use the powerflow output.\n", "\n", @@ -814,7 +783,7 @@ "- Create a new input data set, including both voltage and power sensors\n", "- Use the print statements of assignment 4 to compare the results\n", "\n", - "You should see that the voltages match quite precisely (in the order of microvolts), the *p* and *q* do too (in the order of watts / VARs)." + "You should see that again the voltages match quite precisely (in the order of microvolts), the *p* and *q* do too (in the order of watts / VARs)." ] }, { @@ -1066,12 +1035,12 @@ "output_type": "stream", "text": [ "-------------- nodes --------------\n", - "delta_u: [0.00028959 0.00037244 0.00042541]\n", + "delta_u: [-0.00024486 -0.00016916 -0.00011817]\n", "-------------- lines --------------\n", - "delta_p_from: [ 1.69415257 -0.19360323]\n", - "delta_p_to: [-1.7813758 0.13951295]\n", - "delta_q_from: [-4.79719471 -1.68604537]\n", - "delta_q_to: [4.70671219 1.61927823]\n" + "delta_p_from: [-0.13340325 -0.80568118]\n", + "delta_p_to: [0.04635401 0.75155294]\n", + "delta_q_from: [-4.68525673 -1.66030508]\n", + "delta_q_to: [4.62875468 1.62549793]\n" ] } ], @@ -1114,7 +1083,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "5f70a3ee", "metadata": {}, @@ -1136,14 +1104,14 @@ "\n", "u_angle\n", "pf: [-0.00319565 -0.04673618 -0.06415622]\n", - "se: [ 0. -0.04354054 -0.06096058]\n", + "se: [-0.00319578 -0.04673632 -0.06415637]\n", "\n", "u_angle'\n", "pf: [ 0. -0.04354053 -0.06096057]\n", "se: [ 0. -0.04354054 -0.06096058]\n", "\n", "delta_u_angle\n", - "[ 0.00000000e+00 -1.24601555e-08 -1.52941081e-08]\n" + "[ 0.00000000e+00 -1.32612176e-08 -1.66927135e-08]\n" ] } ], @@ -1172,8 +1140,8 @@ ] }, { - "attachments": {}, "cell_type": "markdown", + "id": "f9a26251", "metadata": {}, "source": [ "# Assignment 7: Time Series Batch Calculation\n", @@ -1220,33 +1188,33 @@ " \n", " \n", " 2022-01-01 00:00:00\n", - " 10577.173048\n", - " 9485.014140\n", - " 9306.838822\n", + " 10606.480633\n", + " 9449.649580\n", + " 9205.568138\n", " \n", " \n", " 2022-01-01 00:15:00\n", - " 10383.156731\n", - " 9561.238330\n", - " 9196.660220\n", + " 10483.366999\n", + " 9727.240644\n", + " 9212.518569\n", " \n", " \n", " 2022-01-01 00:30:00\n", - " 10468.776002\n", - " 9617.045095\n", - " 9291.992823\n", + " 10609.764556\n", + " 9550.070802\n", + " 9362.149158\n", " \n", " \n", " 2022-01-01 00:45:00\n", - " 10638.726675\n", - " 9581.373664\n", - " 9139.434272\n", + " 10574.014241\n", + " 9397.886258\n", + " 9298.033408\n", " \n", " \n", " 2022-01-01 01:00:00\n", - " 10434.418070\n", - " 9379.770132\n", - " 9145.699301\n", + " 10590.212035\n", + " 9590.004470\n", + " 9347.904429\n", " \n", " \n", " ...\n", @@ -1256,33 +1224,33 @@ " \n", " \n", " 2022-01-01 22:45:00\n", - " 10516.502657\n", - " 9605.883339\n", - " 9271.719113\n", + " 10542.595608\n", + " 9512.758258\n", + " 9173.215749\n", " \n", " \n", " 2022-01-01 23:00:00\n", - " 10551.524508\n", - " 9561.235876\n", - " 9175.353526\n", + " 10400.272830\n", + " 9406.056582\n", + " 9233.211454\n", " \n", " \n", " 2022-01-01 23:15:00\n", - " 10479.990630\n", - " 9369.872727\n", - " 9038.040954\n", + " 10582.826242\n", + " 9706.276834\n", + " 9300.629733\n", " \n", " \n", " 2022-01-01 23:30:00\n", - " 10516.245419\n", - " 9346.977853\n", - " 9345.451576\n", + " 10294.027953\n", + " 9580.638345\n", + " 9047.154720\n", " \n", " \n", " 2022-01-01 23:45:00\n", - " 10524.655959\n", - " 9558.837203\n", - " 9339.719284\n", + " 10497.678725\n", + " 9590.450163\n", + " 9187.435950\n", " \n", " \n", "\n", @@ -1291,17 +1259,17 @@ ], "text/plain": [ " 9 10 11\n", - "2022-01-01 00:00:00 10577.173048 9485.014140 9306.838822\n", - "2022-01-01 00:15:00 10383.156731 9561.238330 9196.660220\n", - "2022-01-01 00:30:00 10468.776002 9617.045095 9291.992823\n", - "2022-01-01 00:45:00 10638.726675 9581.373664 9139.434272\n", - "2022-01-01 01:00:00 10434.418070 9379.770132 9145.699301\n", + "2022-01-01 00:00:00 10606.480633 9449.649580 9205.568138\n", + "2022-01-01 00:15:00 10483.366999 9727.240644 9212.518569\n", + "2022-01-01 00:30:00 10609.764556 9550.070802 9362.149158\n", + "2022-01-01 00:45:00 10574.014241 9397.886258 9298.033408\n", + "2022-01-01 01:00:00 10590.212035 9590.004470 9347.904429\n", "... ... ... ...\n", - "2022-01-01 22:45:00 10516.502657 9605.883339 9271.719113\n", - "2022-01-01 23:00:00 10551.524508 9561.235876 9175.353526\n", - "2022-01-01 23:15:00 10479.990630 9369.872727 9038.040954\n", - "2022-01-01 23:30:00 10516.245419 9346.977853 9345.451576\n", - "2022-01-01 23:45:00 10524.655959 9558.837203 9339.719284\n", + "2022-01-01 22:45:00 10542.595608 9512.758258 9173.215749\n", + "2022-01-01 23:00:00 10400.272830 9406.056582 9233.211454\n", + "2022-01-01 23:15:00 10582.826242 9706.276834 9300.629733\n", + "2022-01-01 23:30:00 10294.027953 9580.638345 9047.154720\n", + "2022-01-01 23:45:00 10497.678725 9590.450163 9187.435950\n", "\n", "[96 rows x 3 columns]" ] @@ -1322,7 +1290,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "aadcedbd", "metadata": {}, @@ -1382,7 +1349,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "fe0fe0fa", "metadata": {}, @@ -1405,9 +1371,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "max power load: [21512305.30894372 10581372.96343217]\n", - "min power load: [18554011.90649454 9202715.72274092]\n", - "ratio: [1.15944225 1.14980983]\n" + "max power load: [20318956.68763128 10078884.93969939]\n", + "min power load: [19640245.64115419 9945815.88385369]\n", + "ratio: [1.03455716 1.0133794 ]\n" ] } ], @@ -1423,7 +1389,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "e7e0f878", "metadata": {}, @@ -1439,11 +1404,13 @@ "cell_type": "code", "execution_count": 17, "id": "c87c4179", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1465,13 +1432,22 @@ "plt.ylabel('Loading')\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3d44398", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { + "celltoolbar": "Geen", "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.13 (Standalone)", "language": "python", - "name": "python3" + "name": "python3.13" }, "language_info": { "codemirror_mode": { @@ -1483,7 +1459,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.2" + "version": "3.13.2" } }, "nbformat": 4, diff --git a/state-estimation-assignment/State Estimation Assignment.ipynb b/state-estimation-assignment/State Estimation Assignment.ipynb index 950e6dd..1e98386 100644 --- a/state-estimation-assignment/State Estimation Assignment.ipynb +++ b/state-estimation-assignment/State Estimation Assignment.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "id": "a727ce38", "metadata": {}, @@ -28,7 +27,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "9cd12445", "metadata": {}, @@ -70,7 +68,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "50065790", "metadata": {}, @@ -145,7 +142,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "0c2bad59", "metadata": {}, @@ -167,7 +163,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "0234cab7", "metadata": {}, @@ -194,7 +189,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "940d48be", "metadata": {}, @@ -218,19 +212,13 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "2b013fa7", "metadata": {}, "source": [ "# Assignment 3: Initialize the sensors\n", "\n", - "In this assignment we will perform a state estimation based on three voltage sensors that only measure the voltage. \n", - "If you look closely to the data, you'll notice that the number of measurements (3) is not larger than or equal to the number of unknowns (6). \n", - "So the system is not *fully observable* and you might expect the state estimation to fail. \n", - "However, the linear state estimation algorithm will assume the voltage angles (3) to be zero if no value is given. \n", - "In other words, the mathematical core will give us a faulty result, without any warning! \n", - "To prevent this, we need an observability check, which is complex, but will be added to the validation functions in the future.\n", + "In this assignment we will try to perform a state estimation based on three voltage sensors that only measure the voltage. However, because the number of measurements (3) is lower than the number of unknowns (6), the system is not *fully observable*. This should result in an error.\n", "\n", "- initialize the voltage sensors\n", "- extend the input data set, with the voltage sensors\n", @@ -262,6 +250,52 @@ "model = PowerGridModel(input_data)\n", "\n", "# Run the (iterative linear) state estimation\n", + "try:\n", + " se_output_data = model.calculate_state_estimation(\n", + " symmetric=True,\n", + " error_tolerance=1e-8,\n", + " max_iterations=20,\n", + " calculation_method=CalculationMethod.iterative_linear)\n", + "except Exception as e:\n", + " print(e)\n", + " \n" + ] + }, + { + "cell_type": "markdown", + "id": "ebf8233b", + "metadata": {}, + "source": [ + "# Assignment 4: Add voltage angle measurements\n", + "\n", + "Because the previous result gave an error, we will now add voltage angle measurements. We will alter the `input_data` and construct a new Model\n", + "\n", + "- initialize the voltage sensors again\n", + "- extend the input data set, with the voltage sensors including the voltage angle\n", + "- construct a new model with the new input data\n", + "- run the state estimation calculation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "225cf098", + "metadata": {}, + "outputs": [], + "source": [ + "# Set the voltage angle in the voltage sensor data\n", + "sym_voltage_sensor[\"u_angle_measured\"] = ...\n", + "\n", + "# Add the sensors to the input data\n", + "input_data[...] = sym_voltage_sensor\n", + "\n", + "# Validate the input data\n", + "assert_valid_input_data(..., calculation_type=..., symmetric=...)\n", + "\n", + "# Create a power grid model\n", + "model = PowerGridModel(input_data)\n", + "\n", + "# Run the (iterative linear) state estimation\n", "se_output_data = model.calculate_state_estimation(\n", " symmetric=True, \n", " error_tolerance=1e-8, \n", @@ -270,12 +304,11 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "f4736cc1", "metadata": {}, "source": [ - "# Assignment 4: Compare the results between the loadflow and state estimation\n", + "# Assignment 5: Compare the results between the loadflow and state estimation\n", "\n", "For all nodes:\n", "- print the difference in `u` between `se_output_data` and `pf_output_data`\n", @@ -286,7 +319,7 @@ "- print the difference in `q_from` between `se_output_data` and `pf_output_data`\n", "- print the difference in `q_to` between `se_output_data` and `pf_output_data`\n", "\n", - "You should see that while the voltages match quite precisely (in the order of microvolts), the *p* and *q* are way off (in the order of megawatts / mega VARs). This is as expected because we used voltage angles of 0.0." + "You should see that both the voltages and the *p* and *q* match quite precisely. If you use rounded values as input, there might be a little deviation, but it's rather small compared to the absolute value of *p* and *q*" ] }, { @@ -311,73 +344,13 @@ ] }, { - "attachments": {}, - "cell_type": "markdown", - "id": "683bb610", - "metadata": {}, - "source": [ - "# Assignment 5: Add voltage angle measurements\n", - "\n", - "Now we will update the model by adding voltage angles to the voltage sensors.\n", - "We could alter the `input_data` and construct a new Model, but for the purpose of this workshop (and efficiency) we'll supply the voltage angles as `update_data`, which could potentially be a *batch* calculation in other usecases.\n", - "\n", - "- initialize an update voltage sensor array\n", - "- create an update dataset\n", - "- perform a state estimation, using the update dataset\n", - "- compare the results (as in assignment 4)\n", - "\n", - "You should see that the voltages match quite precisely (in the order of microvolts), the *p* and *q* do too (in the order of 0.01 watts / VARs), because we used the exact voltage angles from the power flow calculation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8628b888", - "metadata": {}, - "outputs": [], - "source": [ - "# TODO: Initialize a voltage sensor update array for 3 sensors\n", - "update_sym_voltage_sensor = initialize_array(..., ..., ...)\n", - "update_sym_voltage_sensor[\"id\"] = ...\n", - "update_sym_voltage_sensor[\"u_angle_measured\"] = ...\n", - "\n", - "# TODO: Create an update dataset \n", - "update_data = {\n", - " ...\n", - "}\n", - "\n", - "# TODO: Validate the update data\n", - "assert_valid_batch_data(..., ..., calculation_type=..., symmetric=...)\n", - "\n", - "# Run the (iterative linear) state estimation\n", - "se_output_data_u_angle = model.calculate_state_estimation(\n", - " update_data = update_data,\n", - " symmetric=True,\n", - " error_tolerance=1e-8, \n", - " max_iterations=20, \n", - " calculation_method=CalculationMethod.iterative_linear)\n", - "\n", - "# TODO: Print the delta u for all nodes (se_output_data_u_angle - pf_output_data)\n", - "print(\"-------------- nodes --------------\")\n", - "print(\"delta_u:\", ...)\n", - "\n", - "# TODO: Print the delta p and q for all lines (se_output_data_u_angle - pf_output_data)\n", - "print(\"-------------- lines --------------\")\n", - "print(\"delta_p_from:\", ...)\n", - "print(\"delta_p_to:\", ...)\n", - "print(\"delta_q_from:\", ...)\n", - "print(\"delta_q_to:\", ...)" - ] - }, - { - "attachments": {}, "cell_type": "markdown", "id": "7b054f55", "metadata": {}, "source": [ "# Assignment 6: Add power sensors to the model\n", "\n", - "In common power grids most voltage sensors only measure the voltage magnitude; not the angle. In this assigment we will again use the `input_data` of assignment 3 (with unknown voltage angles) and we will connect power sensors to the model.\n", + "In common power grids most voltage sensors only measure the voltage magnitude; not the angle. In this assigment we will again use the `input_data` of assignment 3 and we will connect power sensors to the model.\n", "\n", "In our network it would be possible to connect power sensors to the lines, the loads and the source. To assign realistic measurement values to the power sensors we can use the powerflow output.\n", "\n", @@ -386,7 +359,7 @@ "- Create a new input data set, including both voltage and power sensors\n", "- Use the print statements of assignment 4 to compare the results\n", "\n", - "You should see that the voltages match quite precisely (in the order of microvolts), the *p* and *q* do too (in the order of watts / VARs)." + "You should see that again the voltages match quite precisely (in the order of microvolts), the *p* and *q* do too (in the order of watts / VARs)." ] }, { @@ -450,7 +423,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "1afd00f1", "metadata": {}, @@ -490,7 +462,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "4e48d946", "metadata": {}, @@ -522,7 +493,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "4720b175", "metadata": {}, @@ -580,7 +550,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "fb3bf501", "metadata": {}, @@ -611,7 +580,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "27e42d99", "metadata": {}, @@ -646,9 +614,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.13 (Standalone)", "language": "python", - "name": "python3" + "name": "python3.13" }, "language_info": { "codemirror_mode": { @@ -660,7 +628,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.2" + "version": "3.13.2" } }, "nbformat": 4,