From 557e812ad887af36efe29e2533edd254582e03c5 Mon Sep 17 00:00:00 2001 From: ocapron22024 <160739147+ocapron22024@users.noreply.github.com> Date: Tue, 13 Aug 2024 16:53:27 +0200 Subject: [PATCH 1/4] Add files via upload Adaptations made by Luisa: Latest Version 12_08_2024 --- ...at_Network_Four_Consumers_12_08_2024.ipynb | 522 ++++++++++++++++++ 1 file changed, 522 insertions(+) create mode 100644 tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb diff --git a/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb b/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb new file mode 100644 index 00000000..b542e702 --- /dev/null +++ b/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb @@ -0,0 +1,522 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "375e1513", + "metadata": {}, + "source": [ + "# Heating network with for heat comsumers (pandapipes Version 0.9.0)" + ] + }, + { + "cell_type": "raw", + "id": "196b3234", + "metadata": {}, + "source": [ + "This example shows how to set up and solve a heating network\n" + ] + }, + { + "cell_type": "raw", + "id": "bed88633", + "metadata": {}, + "source": [ + "In this example, we will not only calculate the pressure and velocity distribution in the network, but also determine the temperature levels. The pump feeds fluid of a given temperature into the grid. Due to losses, the temperature will fall. The 4 heat consumers remove more heat from the network. On its way back to the pump, the temperature will fall further, but then rise again because of the warmer return flow from the first heat consumpers." + ] + }, + { + "cell_type": "raw", + "id": "cf7d4edb", + "metadata": {}, + "source": [ + "The network is based on the topology of a district heating grid, where the fluid returns to the pump after the consumers (heat exchangers) have been supplied." + ] + }, + { + "cell_type": "raw", + "id": "4d004c1a", + "metadata": {}, + "source": [ + "To set up this network, at first, the pandapipes package has to be imported. Additionally, a net container is created and, at the same time, water as a fluid is chosen." + ] + }, + { + "cell_type": "code", + "execution_count": 296, + "id": "f441de12", + "metadata": {}, + "outputs": [], + "source": [ + "import pandapipes as pp\n", + "\n", + "# create empty net\n", + "net = pp.create_empty_network(fluid =\"water\")" + ] + }, + { + "cell_type": "raw", + "id": "66870dc7", + "metadata": {}, + "source": [ + "Note that the flow of the example network flows in a closed loop. We start building up the network with the junctions connected to the circulation pump j11 for the flow and j00 for the return flow. Note that the numbers are abitary and can be chosen as you like. " + ] + }, + { + "cell_type": "code", + "execution_count": 297, + "id": "5de82e86", + "metadata": {}, + "outputs": [], + "source": [ + "j11 = pp.create_junction(net, pn_bar=5, tfluid_k=293.15, name=\"junction 11\")\n", + "j00 = pp.create_junction(net, pn_bar=5, tfluid_k=293.15, name=\"junction 00\")" + ] + }, + { + "cell_type": "raw", + "id": "a892382c", + "metadata": {}, + "source": [ + "Then we add the junction j2, j3, j4 which are the the flow junction for the heat consumpers. Then we add the junction j5, j6, j7, and j0 " + ] + }, + { + "cell_type": "code", + "execution_count": 298, + "id": "1552998b", + "metadata": {}, + "outputs": [], + "source": [ + "j1 = pp.create_junction(net, pn_bar=5, tfluid_k=293.15, name=\"junction 1\")\n", + "j2 = pp.create_junction(net, pn_bar=5, tfluid_k=293.15, name=\"junction 2\")\n", + "j3 = pp.create_junction(net, pn_bar=5, tfluid_k=293.15, name=\"junction 3\")\n", + "j4 = pp.create_junction(net, pn_bar=5, tfluid_k=293.15, name=\"junction 4\")\n", + "j5 = pp.create_junction(net, pn_bar=5, tfluid_k=293.15, name=\"junction 5\")\n", + "j6 = pp.create_junction(net, pn_bar=5, tfluid_k=293.15, name=\"junction 6\")\n", + "j7 = pp.create_junction(net, pn_bar=5, tfluid_k=293.15, name=\"junction 7\")\n", + "j0 = pp.create_junction(net, pn_bar=5, tfluid_k=293.15, name=\"junction 0\")" + ] + }, + { + "cell_type": "raw", + "id": "e8eb3b68", + "metadata": {}, + "source": [ + "Now, the pump will be created. Note that we use the Circulation Pump Pressure in this example, which is different from the Circulation Pump Mass component used in the \"cicular flow\" example." + ] + }, + { + "cell_type": "code", + "execution_count": 299, + "id": "f6104681", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 299, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pp.create_circ_pump_const_pressure(net, return_junction=j00, flow_junction=j11, p_flow_bar=5, plift_bar=0.7, t_flow_k=273.15+80)" + ] + }, + { + "cell_type": "raw", + "id": "001b4359", + "metadata": {}, + "source": [ + "In the next step we add the four heat consumers. In the old version two elements were combined to create a decent heat consumer. Now it exists as one new element. There are diffrent ways to define the heat consumer as long as it is a combination of two defining variables which includes the mass flow, the exiting heat flow, the returning temperature and the temperature difference. This example for instance uses the mass flow and the exiting heat flow for the first two consumers and the returning temperature combined with the exit heat flow for the other two heat consumers." + ] + }, + { + "cell_type": "code", + "execution_count": 300, + "id": "11ee0328", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 300, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 1. Heat consumer\n", + "pp.create_heat_consumer(net,from_junction=j1, to_junction=j0, diameter_m=200e-3, controlled_mdot_kg_per_s=5, qext_w =100000)\n", + "\n", + "# 2. Heat consumer\n", + "pp.create_heat_consumer(net,from_junction=j2, to_junction=j7, diameter_m=200e-3, controlled_mdot_kg_per_s=5, qext_w =100000)\n", + "\n", + "# 3. Heat consumer \n", + "pp.create_heat_consumer(net,from_junction=j3, to_junction=j6, diameter_m=200e-3,treturn_k=363.15, qext_w =100000)\n", + "\n", + "# 4. Heat consumer \n", + "pp.create_heat_consumer(net,from_junction=j4, to_junction=j5, diameter_m=200e-3, treturn_k=363.15, qext_w =100000)" + ] + }, + { + "cell_type": "raw", + "id": "87bbdc31", + "metadata": {}, + "source": [ + "The missing elements are the pipes. Which will be created next. We start at the pump junction following the flow from consumer to consumer and then back on the return flow to the pump. (see Figure)" + ] + }, + { + "cell_type": "code", + "execution_count": 301, + "id": "cd84392e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 301, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# from pump \"flow\" to first consumer\n", + "pp.create_pipe_from_parameters(net, from_junction=j11, to_junction=j1, length_km=1, \n", + " diameter_m=200e-3, k_mm=.1, alpha_w_per_m2k=5, sections = 5, text_k=283)\n", + "\n", + "# from 1. consumer to 2.consumer \"flow\"\n", + "pp.create_pipe_from_parameters(net, from_junction=j1, to_junction=j2, length_km=1,\n", + " diameter_m=200e-3, k_mm=.1, alpha_w_per_m2k=5, sections = 5, text_k=283)\n", + "\n", + "# from 2. consumer to 3.consumer \"flow\"\n", + "pp.create_pipe_from_parameters(net, from_junction=j2, to_junction=j3, length_km=1,\n", + " diameter_m=200e-3, k_mm=.1, alpha_w_per_m2k=5, sections = 5, text_k=283)\n", + "\n", + "# from 3. consumer to 4.consumer \"flow\"\n", + "pp.create_pipe_from_parameters(net, from_junction=j3, to_junction=j4, length_km=1,\n", + " diameter_m=200e-3, k_mm=.1, alpha_w_per_m2k=5, sections = 5, text_k=283)\n", + "\n", + "# from 4. consumer to 3.consumer \"return flow\"\n", + "pp.create_pipe_from_parameters(net, from_junction=j5, to_junction=j6, length_km=1,\n", + " diameter_m=200e-3, k_mm=.1, alpha_w_per_m2k=5, sections = 5, text_k=283)\n", + "\n", + "# from 3. consumer to 2.consumer \"return flow\"\n", + "pp.create_pipe_from_parameters(net, from_junction=j6, to_junction=j7, length_km=1,\n", + " diameter_m=200e-3, k_mm=.1, alpha_w_per_m2k=5, sections = 5, text_k=283)\n", + "\n", + "# from 2.consumer to 1.consumer \"return flow\"\n", + "pp.create_pipe_from_parameters(net, from_junction=j7, to_junction=j0, length_km=1,\n", + " diameter_m=200e-3, k_mm=.1, alpha_w_per_m2k=5, sections = 5, text_k=283)\n", + "\n", + "# from 1.consumer to pump return flow\n", + "pp.create_pipe_from_parameters(net, from_junction=j0, to_junction=j00, length_km=1, \n", + " diameter_m=200e-3, k_mm=.1, alpha_w_per_m2k=5, sections = 5, text_k=283)" + ] + }, + { + "cell_type": "raw", + "id": "eb7724f4", + "metadata": {}, + "source": [ + "Now it is time to run the pipeflow. Within pipeflow are two different calculation modes \"sequential\" and \"bidirectional\". The sequential mode corresponds to the “all” mode in earlier versions. In this mode the hydraulic calculation takes place first, automatically followed by the thermal calculation. The new mode calculates both, thermal and hydraulic, for each step almost simultaneously since it's working iteratively between the thermal and hydraulic calculations.\n", + "Computed mass flows are used as an input for the temperature calculation. " + ] + }, + { + "cell_type": "raw", + "id": "3255ec46-ad7b-48a1-b6a4-6df7905ff5f0", + "metadata": {}, + "source": [ + "Starting with the calculation of the pipeflow in sequential mode:" + ] + }, + { + "cell_type": "code", + "execution_count": 308, + "id": "d02e3a0f", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "start_seq = time.time() \n", + "pp.pipeflow(net, mode='sequential')\n", + "end_seq = time.time()\n", + "time_seq=end_seq-start_seq" + ] + }, + { + "cell_type": "raw", + "id": "1b467003", + "metadata": {}, + "source": [ + "By default, only the pressure and velocity distribution is calculated by the pipeflow function. After the computation, you can check the results for junctions and pipes:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4045c2b6", + "metadata": {}, + "outputs": [], + "source": [ + "net.res_junction " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6eeef3fe", + "metadata": {}, + "outputs": [], + "source": [ + "net.res_pipe" + ] + }, + { + "cell_type": "raw", + "id": "0f34db00-95ac-4be6-9725-99b73c8b1d5b", + "metadata": {}, + "source": [ + "To compare the results of both calculation modes, the results of sequential mode are saved as:" + ] + }, + { + "cell_type": "code", + "execution_count": 309, + "id": "e68f60a7-f20a-477a-8d26-8d8d75ab373e", + "metadata": {}, + "outputs": [], + "source": [ + "net.res_junction_seq = net.res_junction.copy()\n", + "net.res_pipe_seq = net.res_pipe.copy()" + ] + }, + { + "cell_type": "raw", + "id": "0111c2aa-e25f-4cf9-a11e-81dac67c9607", + "metadata": {}, + "source": [ + "For the bidirectional mode the default settings exceed the interatig boundries, which means that the system cannot converge. Therefore the maximal interating steps have to be increased manually." + ] + }, + { + "cell_type": "code", + "execution_count": 310, + "id": "abe169ae-51e9-4ae4-a9d2-81482713bb37", + "metadata": {}, + "outputs": [], + "source": [ + "start_bi = time.time() \n", + "pp.pipeflow(net, max_iter_bidirect=100, mode='bidirectional')\n", + "end_bi = time.time()\n", + "time_bi=end_bi-start_bi" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1417c474-0571-4d01-bf1b-9340635b9b06", + "metadata": {}, + "outputs": [], + "source": [ + "net.res_junction " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ede94567-eda8-4e7f-92bb-ab33c6988974", + "metadata": {}, + "outputs": [], + "source": [ + "net.res_pipe" + ] + }, + { + "cell_type": "raw", + "id": "88ea651f-7b71-4c09-a4d5-2e7b55be1d80", + "metadata": {}, + "source": [ + "The results of bidirectional mode are saved as:" + ] + }, + { + "cell_type": "code", + "execution_count": 311, + "id": "d22c787f-145d-4170-b85f-cf425a85c696", + "metadata": {}, + "outputs": [], + "source": [ + "net.res_junction_bi = net.res_junction.copy()\n", + "net.res_pipe_bi = net.res_pipe.copy()" + ] + }, + { + "cell_type": "raw", + "id": "b30d3eec-b56f-4cc7-bf6d-f775e1f1bfbd", + "metadata": {}, + "source": [ + "Now it is possible to graphicly compare any of the calculated components: For example, the calculated temperatures in both modes or the mass flow can be plotted. " + ] + }, + { + "cell_type": "code", + "execution_count": 312, + "id": "f3643a15-ba3f-4d6f-bfbc-c722190c4cfb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(net.res_pipe_seq.t_from_k, color='blue', marker='o',label='sequential',linestyle='None')\n", + "plt.plot(net.res_pipe_bi.t_from_k, color = 'orange', marker='x',label='bidirectional',linestyle='None')\n", + "plt.xlabel('Pipe number')\n", + "plt.ylabel('Temperature in K')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7562fb7f-7e79-44fc-b3c8-74ec95254c11", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(net.res_pipe_seq.mdot_from_kg_per_s,color='blue', marker='o',label='sequential',linestyle='None')\n", + "plt.plot(net.res_pipe_bi.mdot_from_kg_per_s, color = 'orange', marker='x',label='bidirectional',linestyle='None')\n", + "plt.xlabel('Pipe number')\n", + "plt.ylabel('Mass flow in kg/s')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "raw", + "id": "154ee211-c2c4-48ed-b195-10ae4113e539", + "metadata": {}, + "source": [ + "To estimate the real differences, the absolute and percentage differences are calculated and displayed in a table. The respective runtimes for the calculation modes can also be found here." + ] + }, + { + "cell_type": "code", + "execution_count": 313, + "id": "1dbe89b8-d571-44d8-b60d-7035f16c339f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Diff_t_from Diff_t_from_in_percent Diff_mass Diff_mass_in_percent \\\n", + "0 0.000000 0.000000 0.017405 0.186807 \n", + "1 0.009707 0.002791 0.017405 0.403168 \n", + "2 0.217888 0.065632 0.017405 2.548372 \n", + "3 2.234560 0.682596 0.038830 11.370867 \n", + "4 0.432291 0.151910 0.038830 11.370867 \n", + "5 0.350282 0.117685 0.017405 2.548372 \n", + "6 0.217977 0.066618 0.017405 0.403168 \n", + "7 0.079587 0.023944 0.017405 0.186807 \n", + "\n", + " time_seq time_bi \n", + "0 0.013051 0.024827 \n", + "1 0.013051 0.024827 \n", + "2 0.013051 0.024827 \n", + "3 0.013051 0.024827 \n", + "4 0.013051 0.024827 \n", + "5 0.013051 0.024827 \n", + "6 0.013051 0.024827 \n", + "7 0.013051 0.024827 \n" + ] + } + ], + "source": [ + "# Temperatur output\n", + "Diff_t_from=abs(net.res_pipe_seq.t_from_k-net.res_pipe_bi.t_from_k)\n", + "Diff_t_from_percent=abs(net.res_pipe_seq.t_from_k-net.res_pipe_bi.t_from_k)/net.res_pipe_seq.t_from_k*100\n", + "# Massflow\n", + "Diff_mass=abs(net.res_pipe_seq.mdot_from_kg_per_s-net.res_pipe_bi.mdot_from_kg_per_s)\n", + "Diff_mass_percent=abs(net.res_pipe_seq.mdot_from_kg_per_s-net.res_pipe_bi.mdot_from_kg_per_s)/abs(net.res_pipe_seq.mdot_from_kg_per_s)*100\n", + "\n", + "diff_tab =pd.DataFrame({'Diff_t_from':Diff_t_from,\n", + " 'Diff_t_from_in_percent':Diff_t_from_percent,\n", + " 'Diff_mass':Diff_mass,\n", + " 'Diff_mass_in_percent':Diff_mass_percent,\n", + " 'time_seq':time_seq,\n", + " 'time_bi':time_bi})\n", + "print(diff_tab)" + ] + }, + { + "cell_type": "raw", + "id": "3cd5261d-c328-4eb1-9c51-c0b04716bcb4", + "metadata": {}, + "source": [ + "This shows that with different calculation modes, slight deviations in temperature and some in the mass flow occur using the diffrent calculation modes." + ] + }, + { + "cell_type": "raw", + "id": "2dd64725-d547-4668-b8c5-a70485a14b27", + "metadata": {}, + "source": [ + "Questions:\n", + "- How do I know which one is better? Can I compare it to reallife measurments or how do I validate and evaluate the results?\n", + "- The measured time varies sometimes if the hole tutorial is repeated. Is that normal or does it affect the significance of the time so that it isn't a good criteria?\n", + "- Is it smart to compare the output temperature or a temperature in general? " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb4a3f9f-f6ca-4b2e-b4f5-6c5a75681054", + "metadata": {}, + "outputs": [], + "source": [ + "net._internal_results" + ] + } + ], + "metadata": { + "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.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 12f80f5b5ef3c8b64c95a3c2c35b3908dbaba79f Mon Sep 17 00:00:00 2001 From: EPrade <90843651+EPrade@users.noreply.github.com> Date: Mon, 2 Sep 2024 11:15:05 +0200 Subject: [PATCH 2/4] Update Heat_Network_Four_Consumers_12_08_2024.ipynb --- tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb | 1 + 1 file changed, 1 insertion(+) diff --git a/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb b/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb index b542e702..8fec8eea 100644 --- a/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb +++ b/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb @@ -388,6 +388,7 @@ } ], "source": [ + "import matplotlib.pyplot as plt", "plt.plot(net.res_pipe_seq.t_from_k, color='blue', marker='o',label='sequential',linestyle='None')\n", "plt.plot(net.res_pipe_bi.t_from_k, color = 'orange', marker='x',label='bidirectional',linestyle='None')\n", "plt.xlabel('Pipe number')\n", From b4df4e7083f10b5163e1862b8c5fa584d263bc1b Mon Sep 17 00:00:00 2001 From: EPrade <90843651+EPrade@users.noreply.github.com> Date: Mon, 2 Sep 2024 11:15:43 +0200 Subject: [PATCH 3/4] Update Heat_Network_Four_Consumers_12_08_2024.ipynb --- tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb b/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb index 8fec8eea..d797a993 100644 --- a/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb +++ b/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb @@ -388,7 +388,7 @@ } ], "source": [ - "import matplotlib.pyplot as plt", + "import matplotlib.pyplot as plt\n", "plt.plot(net.res_pipe_seq.t_from_k, color='blue', marker='o',label='sequential',linestyle='None')\n", "plt.plot(net.res_pipe_bi.t_from_k, color = 'orange', marker='x',label='bidirectional',linestyle='None')\n", "plt.xlabel('Pipe number')\n", From 4c976802742cd6cd2db11b90b68ffd553b60ea17 Mon Sep 17 00:00:00 2001 From: EPrade <90843651+EPrade@users.noreply.github.com> Date: Mon, 2 Sep 2024 11:29:07 +0200 Subject: [PATCH 4/4] Update Heat_Network_Four_Consumers_12_08_2024.ipynb --- tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb | 1 + 1 file changed, 1 insertion(+) diff --git a/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb b/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb index d797a993..9c419fc4 100644 --- a/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb +++ b/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb @@ -454,6 +454,7 @@ ], "source": [ "# Temperatur output\n", + "import pandas as pd\n", "Diff_t_from=abs(net.res_pipe_seq.t_from_k-net.res_pipe_bi.t_from_k)\n", "Diff_t_from_percent=abs(net.res_pipe_seq.t_from_k-net.res_pipe_bi.t_from_k)/net.res_pipe_seq.t_from_k*100\n", "# Massflow\n",