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 000000000..9c419fc4f --- /dev/null +++ b/tutorials/Heat_Network_Four_Consumers_12_08_2024.ipynb @@ -0,0 +1,524 @@ +{ + "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": [ + "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", + "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", + "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", + "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 +}