From d4600b5926d76638ae6d7cf3255bc97d35ae868d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Georg=20=C2=B4Brantegger?= Date: Thu, 9 Jun 2022 15:00:40 +0200 Subject: [PATCH 01/13] Volume and height changes dependend on flux profiles --- Druckrohrleitung.py | 17 +++++++++++++++++ __pycache__/Druckrohrleitung.cpython-38.pyc | Bin 0 -> 718 bytes 2 files changed, 17 insertions(+) create mode 100644 __pycache__/Druckrohrleitung.cpython-38.pyc diff --git a/Druckrohrleitung.py b/Druckrohrleitung.py index e69de29..2aeb9d9 100644 --- a/Druckrohrleitung.py +++ b/Druckrohrleitung.py @@ -0,0 +1,17 @@ +import numpy as np + +def simple_time_delay(delta_p_profile,delay,timestep): + rounded_delay = timestep * np.round(delay/timestep) + print('Delay was rounded to ', rounded_delay) + n_pad = int(rounded_delay/timestep) + output_delta_p_profile = np.pad(delta_p_profile[0:-n_pad],[n_pad,0],constant_values=0) + return output_delta_p_profile + +## testing +if __name__ == "__main__": + delta_p_profile = np.ones([100]) + delay = 4 + timestep = 0.2 + + print(simple_time_delay(delta_p_profile, delay, timestep)) + diff --git a/__pycache__/Druckrohrleitung.cpython-38.pyc b/__pycache__/Druckrohrleitung.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82b5992033035e9dac453474553e485a0a559029 GIT binary patch literal 718 zcmYjPKW`H;6t{hLaw$zC5FilCtyx&u5NZp}hE!E5Fq}@ZuCcisxwB8UuPD`J3XFUJ znA(vqz!zZRD|ls!#Dv7ob6P>3^nTX+y+6Mv+pmYi9R&9K*VWk}LFi`)wv9n>2yR~h z2qbWYQY?swKA@DyNYFVk`x0ML!9=ehS2$&&pY}wY_GK)IWU?pwt7wHW^q!*eU=4H7 z@iYp@jrHLSI!EC44M0a6y2Kss$Rl)x@1kYoh`?R6A{e=-ivqvGOA1xAgNh|{=pE~j zARX)I1N4zRL>(2RAYs!_(X!X|K${+4+?&WMUnK8yn;6|HAw}YJVlaq~u^&yfvMyJS zpXXI8?YQTOYCPMNde)dyIUfa}w!Dx&YH~5|`;m~9%Xz~aqu-X5^bCl6;bT|U(mL6s z!y7TaNu*41==4~n_jT)<)&+ih!dGO5u+kp`aQ-waq&7u1(bKk;%GvBh8vFg5s>=1_{~u3GJDnRnGZpl Date: Thu, 9 Jun 2022 15:01:25 +0200 Subject: [PATCH 02/13] simple time delay function added --- Ausgleichsbecken.py | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/Ausgleichsbecken.py b/Ausgleichsbecken.py index e69de29..f56b829 100644 --- a/Ausgleichsbecken.py +++ b/Ausgleichsbecken.py @@ -0,0 +1,35 @@ +import numpy as np + +def Volume_trend(influx,outflux,timestep=1,V_0=0): + ''' + Returns the trend and the volume and the final volume, defined + by influx and outflux patterns. The optional parameter timestep + defines the time increment over which the fluxes are changing. + ''' + net_flux = influx-outflux + delta_V = net_flux*timestep + V_trend = V_0+np.cumsum(delta_V) + V_end = V_trend[-1] + return V_end, V_trend + +def Height_trend(V_trend,area=1,h_crit_low=-np.inf,h_crit_high=np.inf): + ''' + Returns the trend and the height and the final height, defined + by influx and outflux patterns as well as the crosssection area. + The optional parameters h_crit_low/high indicate limits that the height + should never exceed. If this occures, TRUE is returned in the corresponding + h_crit_flag. + ''' + h_trend = V_trend/area + h_crit_flag_low = np.any(h_trend <= h_crit_low) + h_crit_flag_high = np.any(h_trend >= h_crit_high) + h_end = h_trend[-1] + return h_trend,h_end,h_crit_flag_low,h_crit_flag_high + +## testing +if __name__ == "__main__": + influx = np.full([1,100], 6) + outflux = np.full_like(influx, 4) + V_end, V_trend = Volume_trend(influx, outflux,timestep=0.5,V_0 = 100) + print(V_end) + print(V_trend) From 12b362523efc450b1a0359fb8ed71f7186544915 Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 13 Jun 2022 15:02:34 +0200 Subject: [PATCH 03/13] added unapplicable hagen Poiseuille --- Durchflussraten.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/Durchflussraten.py b/Durchflussraten.py index e69de29..d6f6b70 100644 --- a/Durchflussraten.py +++ b/Durchflussraten.py @@ -0,0 +1,14 @@ +import numpy as np +from math import pi + + +def Hagen_Poiseuille(dP,dx,r,vis): + Q = (pi*r**4)/(8*vis)*dP/dx + return Q + + +def get_Q_from_dP(P_above,P_below,dx,constants=[1,1]): + r = constants[0] + vis = constants[1] + + From aa2939bf8bfa330e1f0ef003fc1accef0170bdb1 Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 13 Jun 2022 15:03:01 +0200 Subject: [PATCH 04/13] started work on e-RK-4 for outflux calculation --- Ausgleichsbecken.py | 58 +++++++++++++++++++++++++++++++++++---------- 1 file changed, 45 insertions(+), 13 deletions(-) diff --git a/Ausgleichsbecken.py b/Ausgleichsbecken.py index f56b829..f082c2a 100644 --- a/Ausgleichsbecken.py +++ b/Ausgleichsbecken.py @@ -1,8 +1,8 @@ import numpy as np -def Volume_trend(influx,outflux,timestep=1,V_0=0): +def Volume_trend(influx, outflux, timestep=1, V_0=0): ''' - Returns the trend and the volume and the final volume, defined + Returns the trend and the volume and the final volume, defined by influx and outflux patterns. The optional parameter timestep defines the time increment over which the fluxes are changing. ''' @@ -10,26 +10,58 @@ def Volume_trend(influx,outflux,timestep=1,V_0=0): delta_V = net_flux*timestep V_trend = V_0+np.cumsum(delta_V) V_end = V_trend[-1] - return V_end, V_trend + return V_end, V_trend -def Height_trend(V_trend,area=1,h_crit_low=-np.inf,h_crit_high=np.inf): +def Height_trend(V_trend, area=1, h_crit_low=-np.inf, h_crit_high=np.inf): ''' - Returns the trend and the height and the final height, defined + Returns the trend and the height and the final height, defined by influx and outflux patterns as well as the crosssection area. The optional parameters h_crit_low/high indicate limits that the height - should never exceed. If this occures, TRUE is returned in the corresponding + should never exceed. If this occures, TRUE is returned in the corresponding h_crit_flag. ''' h_trend = V_trend/area h_crit_flag_low = np.any(h_trend <= h_crit_low) h_crit_flag_high = np.any(h_trend >= h_crit_high) h_end = h_trend[-1] - return h_trend,h_end,h_crit_flag_low,h_crit_flag_high + return h_trend, h_end, h_crit_flag_low, h_crit_flag_high + +def get_h_halfstep(initial_height, influx, outflux, timestep, area): + h0 = initial_height + Q_in = influx + Q_out = outflux + dt = timestep + A = area + + h_halfstep = h0+1/A*(Q_in-Q_out)*dt/2 + +def get_p_halfstep(p0, p1): + p_halfstep = (p0+p1)/2 + +def FODE_function(x, h, alpha, p, rho=1000, g=9.81): + f = x**2/h*alpha+g+p/(rho*h) + return f + + +def e_RK_4(yn, h, dt, Q0, Q1, A0, A1, p0, p1): + alpha = (A1/A0-1) + + h_hs = get_h_halfstep(h, Q0, Q1, dt, A0) + p_hs = get_p_halfstep(p0, p1) + Y1 = yn + Y2 = yn + dt/2*FODE_function(Y1, h, alpha, p0) + Y3 = yn + dt/2*FODE_function(Y2, h_hs, alpha, p_hs) + Y4 = yn + dt*FODE_function(Y3, h_hs, alpha, p_hs) + ynp1 = yn + dt/6*(FODE_function(Y1, h, alpha, p)+2*FODE_function(Y2, h_hs, alpha, p_hs)+ \ + 2*FODE_function(Y3, h_hs, alpha, p_hs)+ FODE_function(Y4, h, alpha, p)) + + + ## testing -if __name__ == "__main__": - influx = np.full([1,100], 6) - outflux = np.full_like(influx, 4) - V_end, V_trend = Volume_trend(influx, outflux,timestep=0.5,V_0 = 100) - print(V_end) - print(V_trend) +# if __name__ == "__main__": +# influx = np.full([1, 100], 6) +# outflux = np.full_like(influx, 4) +# V_end, V_trend = Volume_trend(influx, outflux, timestep=0.5, V_0 = 100) +# print(V_end) +# print(V_trend) From d73bc99f4974ad0ca8ddd5748f9430f49c736656 Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 13 Jun 2022 15:04:56 +0200 Subject: [PATCH 05/13] now actually added unapplicable Hagen Poiseuille --- Durchflussraten.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/Durchflussraten.py b/Durchflussraten.py index d6f6b70..bbef2d1 100644 --- a/Durchflussraten.py +++ b/Durchflussraten.py @@ -2,13 +2,11 @@ import numpy as np from math import pi -def Hagen_Poiseuille(dP,dx,r,vis): +def Hagen_Poiseuille(P_above,P_below,dx,constants=[1,1]): + dP = P_above-P_below + r = constants[0] + vis = constants[1] Q = (pi*r**4)/(8*vis)*dP/dx return Q -def get_Q_from_dP(P_above,P_below,dx,constants=[1,1]): - r = constants[0] - vis = constants[1] - - From 115e59af3bffc772958535d41164345d7f922cdb Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Tue, 14 Jun 2022 14:25:51 +0200 Subject: [PATCH 06/13] build a programm to test e-RK4-function - NOT WORKING YET --- .gitignore | 2 + Ausgleichsbecken.py | 4 +- Ausgleichsbecken_class_file.py | 84 ++++++++++++++++++++++++++++++ Messing Around/Messy_py.py | 11 ++-- e-RK4-Test.ipynb | 93 ++++++++++++++++++++++++++++++++++ 5 files changed, 189 insertions(+), 5 deletions(-) create mode 100644 Ausgleichsbecken_class_file.py create mode 100644 e-RK4-Test.ipynb diff --git a/.gitignore b/.gitignore index d373fe0..95fdff4 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ 2bignored.txt functions/__pycache__/ .vscode/settings.json +__pycache__/Ausgleichsbecken_class_file.cpython-38.pyc +__pycache__/Ausgleichsbecken.cpython-38.pyc diff --git a/Ausgleichsbecken.py b/Ausgleichsbecken.py index f082c2a..c4d9165 100644 --- a/Ausgleichsbecken.py +++ b/Ausgleichsbecken.py @@ -38,8 +38,8 @@ def get_h_halfstep(initial_height, influx, outflux, timestep, area): def get_p_halfstep(p0, p1): p_halfstep = (p0+p1)/2 -def FODE_function(x, h, alpha, p, rho=1000, g=9.81): - f = x**2/h*alpha+g+p/(rho*h) +def FODE_function(x, h, alpha, p, rho=1000., g=9.81): + f = x**2/h*alpha+g-p/(rho*h) return f diff --git a/Ausgleichsbecken_class_file.py b/Ausgleichsbecken_class_file.py new file mode 100644 index 0000000..8f0b24f --- /dev/null +++ b/Ausgleichsbecken_class_file.py @@ -0,0 +1,84 @@ +from Ausgleichsbecken import FODE_function, get_h_halfstep, get_p_halfstep +class Ausgleichsbecken_class: +# units + area_unit = 'm^2' + area_outflux_unit = 'm^2' + level_unit = 'm' + volume_unit = 'm^3' + flux_unit = 'm^3/s' + time_unit = 's' + +# init + def __init__(self,area,outflux_area,level_min,level_max,timestep = 1): + self.area = area # base area of the rectangular structure + self.area_outflux = outflux_area # area of the outlet towards the pipeline + self.level_min = level_min # lowest allowed water level + self.level_max = level_max # highest allowed water level + self.timestep = timestep # timestep of the simulation + +# setter + def set_volume(self): + self.volume = self.level*self.area + + def set_initial_level(self,initial_level): + self.level = initial_level + self.set_volume() + + def set_influx(self,influx): + self.influx = influx + + def set_outflux(self,outflux): + self.outflux = outflux + +# getter + def get_area(self): + print('The base area of the cuboid reservoir is', self.area, self.area_unit) + + def get_outflux_area(self): + print('The outflux area from the cuboid reservoir to the pipeline is', \ + self.area_outflux, self.area_outflux_unit) + + def get_level(self): + print('The current level in the reservoir is', self.level , self.level_unit) + + def get_crit_levels(self): + print('The critical water levels in the reservoir are: \n',\ + ' Minimum:', self.level_min , self.level_unit , '\n',\ + ' Maximum:', self.level_max , self.level_unit ) + + def get_volume(self): + print('The current water volume in the reservoir is', self.volume, self.volume_unit) + + def get_timestep(self): + print('The timestep for the simulation is' , self.timestep, self.time_unit) + + def get_influx(self): + print('The current influx is', self.influx, self.flux_unit) + + def get_outflux(self): + print('The current outflux is', self.outflux, self.flux_unit) + +# methods + def update_level(self,timestep): + net_flux = self.influx-self.outflux + delta_V = net_flux*timestep + new_level = (self.volume+delta_V)/self.area + return new_level + + + def e_RK_4(self): + yn = self.outflux/self.area_outflux + h = self.level + dt = self.timestep + p = self.p0 + p_hs = self.p0 + alpha = (self.area/self.area_outflux-1) + h_hs = self.update_level(dt/2) + Y1 = yn + Y2 = yn + dt/2*FODE_function(Y1, h, alpha, self.p0) + Y3 = yn + dt/2*FODE_function(Y2, h_hs, alpha, p_hs) + Y4 = yn + dt*FODE_function(Y3, h_hs, alpha, p_hs) + ynp1 = yn + dt/6*(FODE_function(Y1, h, alpha, p)+2*FODE_function(Y2, h_hs, alpha, p_hs)+ \ + 2*FODE_function(Y3, h_hs, alpha, p_hs)+ FODE_function(Y4, h, alpha, p)) + + self.outflux = ynp1*self.area_outflux \ No newline at end of file diff --git a/Messing Around/Messy_py.py b/Messing Around/Messy_py.py index c10b928..7d7d927 100644 --- a/Messing Around/Messy_py.py +++ b/Messing Around/Messy_py.py @@ -1,4 +1,9 @@ -import numpy as np -print(np.__version__) +class Person: + def __init__(self, name, age): + self.name = name + self.age = age -print("Test for Github commit") +p1 = Person("John", 36) + +print(p1.name) +print(p1.age) diff --git a/e-RK4-Test.ipynb b/e-RK4-Test.ipynb new file mode 100644 index 0000000..bf6414c --- /dev/null +++ b/e-RK4-Test.ipynb @@ -0,0 +1,93 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from Ausgleichsbecken_class_file import Ausgleichsbecken_class\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.707892426750419\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "t_max = 0.8\n", + "V = Ausgleichsbecken_class(1.,0.5,0.,10.,timestep=0.001)\n", + "t_vec = np.arange(0,t_max,V.timestep)\n", + "\n", + "V.set_initial_level(5.) \n", + "V.set_influx(0.)\n", + "V.set_outflux(0.)\n", + "\n", + "V.p0 = 0.\n", + "\n", + "outflux_vec = np.zeros_like(t_vec)\n", + "level_vec = np.zeros_like(t_vec)\n", + "\n", + "for i in range(np.size(t_vec)):\n", + " t = t_vec[i]\n", + " V.e_RK_4()\n", + " V.level = V.update_level(V.timestep)\n", + " V.set_volume()\n", + " outflux_vec[i] = V.outflux\n", + " level_vec[i] = V.level\n", + " \n", + "plt.plot(level_vec)\n", + "print(level_vec[-1])\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", + "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.8.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 5bb223fedb8e97003daa1131d4741b809d8ebdbc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Georg=20=C2=B4Brantegger?= Date: Wed, 15 Jun 2022 10:15:18 +0200 Subject: [PATCH 07/13] looks like e-RK4 is working :D --- Ausgleichsbecken_class_file.py | 2 +- e-RK4-Test.ipynb | 139 ++++++++++++++++++++++++++++----- 2 files changed, 120 insertions(+), 21 deletions(-) diff --git a/Ausgleichsbecken_class_file.py b/Ausgleichsbecken_class_file.py index 8f0b24f..781cb51 100644 --- a/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken_class_file.py @@ -72,7 +72,7 @@ class Ausgleichsbecken_class: dt = self.timestep p = self.p0 p_hs = self.p0 - alpha = (self.area/self.area_outflux-1) + alpha = (self.area_outflux/self.area-1) h_hs = self.update_level(dt/2) Y1 = yn Y2 = yn + dt/2*FODE_function(Y1, h, alpha, self.p0) diff --git a/e-RK4-Test.ipynb b/e-RK4-Test.ipynb index bf6414c..147f48f 100644 --- a/e-RK4-Test.ipynb +++ b/e-RK4-Test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -13,19 +13,63 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 7, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "2.707892426750419\n" + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mv:\\georg\\Documents\\Persönliche Dokumente\\Arbeit\\Kelag\\Coding\\Python\\DT_Slot_3\\Kelag_DT_Slot_3\\e-RK4-Test.ipynb Cell 2'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 12\u001b[0m \u001b[39mwhile\u001b[39;00m V\u001b[39m.\u001b[39mlevel \u001b[39m>\u001b[39m \u001b[39m0.005\u001b[39m:\n\u001b[0;32m 13\u001b[0m t \u001b[39m=\u001b[39m t\u001b[39m+\u001b[39mV\u001b[39m.\u001b[39mtimestep\n\u001b[1;32m---> 14\u001b[0m V\u001b[39m.\u001b[39;49me_RK_4()\n\u001b[0;32m 15\u001b[0m V\u001b[39m.\u001b[39mlevel \u001b[39m=\u001b[39m V\u001b[39m.\u001b[39mupdate_level(V\u001b[39m.\u001b[39mtimestep)\n\u001b[0;32m 16\u001b[0m V\u001b[39m.\u001b[39mset_volume()\n", + "File \u001b[1;32mv:\\georg\\Documents\\Persönliche Dokumente\\Arbeit\\Kelag\\Coding\\Python\\DT_Slot_3\\Kelag_DT_Slot_3\\Ausgleichsbecken_class_file.py:81\u001b[0m, in \u001b[0;36mAusgleichsbecken_class.e_RK_4\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 79\u001b[0m Y3 \u001b[39m=\u001b[39m yn \u001b[39m+\u001b[39m dt\u001b[39m/\u001b[39m\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mFODE_function(Y2, h_hs, alpha, p_hs)\n\u001b[0;32m 80\u001b[0m Y4 \u001b[39m=\u001b[39m yn \u001b[39m+\u001b[39m dt\u001b[39m*\u001b[39mFODE_function(Y3, h_hs, alpha, p_hs)\n\u001b[1;32m---> 81\u001b[0m ynp1 \u001b[39m=\u001b[39m yn \u001b[39m+\u001b[39m dt\u001b[39m/\u001b[39m\u001b[39m6\u001b[39m\u001b[39m*\u001b[39m(FODE_function(Y1, h, alpha, p)\u001b[39m+\u001b[39m\u001b[39m2\u001b[39;49m\u001b[39m*\u001b[39;49mFODE_function(Y2, h_hs, alpha, p_hs)\u001b[39m+\u001b[39m \\\n\u001b[0;32m 82\u001b[0m \u001b[39m2\u001b[39m\u001b[39m*\u001b[39mFODE_function(Y3, h_hs, alpha, p_hs)\u001b[39m+\u001b[39m FODE_function(Y4, h, alpha, p))\n\u001b[0;32m 84\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39moutflux \u001b[39m=\u001b[39m ynp1\u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39marea_outflux\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " ] + } + ], + "source": [ + "V = Ausgleichsbecken_class(1.,0.5,0.,10.,timestep=0.001)\n", + "V.set_initial_level(5.) \n", + "V.set_influx(1.)\n", + "V.set_outflux(0.)\n", + "\n", + "V.p0 = 0.\n", + "\n", + "outflux_vec = []\n", + "level_vec = []\n", + "\n", + "t = 0\n", + "while V.level > 0.005:\n", + " t = t+V.timestep\n", + " V.e_RK_4()\n", + " V.level = V.update_level(V.timestep)\n", + " V.set_volume()\n", + " outflux_vec.append(V.outflux)\n", + " level_vec.append(V.level)\n", + " \n", + "plt.plot(level_vec)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -37,35 +81,90 @@ } ], "source": [ - "t_max = 0.8\n", - "V = Ausgleichsbecken_class(1.,0.5,0.,10.,timestep=0.001)\n", - "t_vec = np.arange(0,t_max,V.timestep)\n", + "V = Ausgleichsbecken_class(1.,0.1,0.,10.,timestep=0.001)\n", "\n", "V.set_initial_level(5.) \n", - "V.set_influx(0.)\n", + "V.set_influx(0.75)\n", "V.set_outflux(0.)\n", "\n", "V.p0 = 0.\n", "\n", - "outflux_vec = np.zeros_like(t_vec)\n", - "level_vec = np.zeros_like(t_vec)\n", + "outflux_vec = []\n", + "level_vec = []\n", "\n", - "for i in range(np.size(t_vec)):\n", - " t = t_vec[i]\n", + "t = 0\n", + "while V.level > 0.01:\n", + " t = t+V.timestep\n", " V.e_RK_4()\n", " V.level = V.update_level(V.timestep)\n", " V.set_volume()\n", - " outflux_vec[i] = V.outflux\n", - " level_vec[i] = V.level\n", + " outflux_vec.append(V.outflux)\n", + " level_vec.append(V.level)\n", + " if t > 100:\n", + " break\n", " \n", - "plt.plot(level_vec)\n", - "print(level_vec[-1])\n" + "plt.plot(level_vec)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "V = Ausgleichsbecken_class(1.,0.9,0.,10.,timestep=0.001)\n", + "\n", + "V.set_initial_level(10.) \n", + "V.set_influx(3.2)\n", + "V.set_outflux(0.)\n", + "\n", + "V.p0 = 0.\n", + "\n", + "outflux_vec = []\n", + "level_vec = []\n", + "\n", + "t = 0\n", + "while V.level > 0.005:\n", + " t = t+V.timestep\n", + " V.e_RK_4()\n", + " V.level = V.update_level(V.timestep)\n", + " V.set_volume()\n", + " outflux_vec.append(V.outflux)\n", + " level_vec.append(V.level)\n", + " \n", + "plt.plot(level_vec)\n" ] } ], "metadata": { + "interpreter": { + "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" + }, "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", + "display_name": "Python 3.8.13 ('DT_Slot_3')", "language": "python", "name": "python3" }, From 6df9bfcda6061160b054418831a7caf71823ed3c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Georg=20=C2=B4Brantegger?= Date: Wed, 15 Jun 2022 14:59:48 +0200 Subject: [PATCH 08/13] commit for sync 15.06. --- Main_Program.ipynb | 30 +++++++++++++ e-RK4-Test.ipynb | 109 +++++++++++++++++++++++++++++---------------- 2 files changed, 100 insertions(+), 39 deletions(-) diff --git a/Main_Program.ipynb b/Main_Program.ipynb index e69de29..3557ac5 100644 --- a/Main_Program.ipynb +++ b/Main_Program.ipynb @@ -0,0 +1,30 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('DT_Slot_3')", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.8.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/e-RK4-Test.ipynb b/e-RK4-Test.ipynb index 147f48f..9acfd87 100644 --- a/e-RK4-Test.ipynb +++ b/e-RK4-Test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -13,63 +13,92 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# define constants\n", + "initial_level = 5.\n", + "initial_influx = 3. \n", + "initial_outflux = 0. \n", + "initial_pipeline_pressure = 0. \n", + "\n", + "total_min_level = 0.01\n", + "total_max_time = 100\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, "metadata": {}, "outputs": [ { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[1;32mv:\\georg\\Documents\\Persönliche Dokumente\\Arbeit\\Kelag\\Coding\\Python\\DT_Slot_3\\Kelag_DT_Slot_3\\e-RK4-Test.ipynb Cell 2'\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 12\u001b[0m \u001b[39mwhile\u001b[39;00m V\u001b[39m.\u001b[39mlevel \u001b[39m>\u001b[39m \u001b[39m0.005\u001b[39m:\n\u001b[0;32m 13\u001b[0m t \u001b[39m=\u001b[39m t\u001b[39m+\u001b[39mV\u001b[39m.\u001b[39mtimestep\n\u001b[1;32m---> 14\u001b[0m V\u001b[39m.\u001b[39;49me_RK_4()\n\u001b[0;32m 15\u001b[0m V\u001b[39m.\u001b[39mlevel \u001b[39m=\u001b[39m V\u001b[39m.\u001b[39mupdate_level(V\u001b[39m.\u001b[39mtimestep)\n\u001b[0;32m 16\u001b[0m V\u001b[39m.\u001b[39mset_volume()\n", - "File \u001b[1;32mv:\\georg\\Documents\\Persönliche Dokumente\\Arbeit\\Kelag\\Coding\\Python\\DT_Slot_3\\Kelag_DT_Slot_3\\Ausgleichsbecken_class_file.py:81\u001b[0m, in \u001b[0;36mAusgleichsbecken_class.e_RK_4\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 79\u001b[0m Y3 \u001b[39m=\u001b[39m yn \u001b[39m+\u001b[39m dt\u001b[39m/\u001b[39m\u001b[39m2\u001b[39m\u001b[39m*\u001b[39mFODE_function(Y2, h_hs, alpha, p_hs)\n\u001b[0;32m 80\u001b[0m Y4 \u001b[39m=\u001b[39m yn \u001b[39m+\u001b[39m dt\u001b[39m*\u001b[39mFODE_function(Y3, h_hs, alpha, p_hs)\n\u001b[1;32m---> 81\u001b[0m ynp1 \u001b[39m=\u001b[39m yn \u001b[39m+\u001b[39m dt\u001b[39m/\u001b[39m\u001b[39m6\u001b[39m\u001b[39m*\u001b[39m(FODE_function(Y1, h, alpha, p)\u001b[39m+\u001b[39m\u001b[39m2\u001b[39;49m\u001b[39m*\u001b[39;49mFODE_function(Y2, h_hs, alpha, p_hs)\u001b[39m+\u001b[39m \\\n\u001b[0;32m 82\u001b[0m \u001b[39m2\u001b[39m\u001b[39m*\u001b[39mFODE_function(Y3, h_hs, alpha, p_hs)\u001b[39m+\u001b[39m FODE_function(Y4, h, alpha, p))\n\u001b[0;32m 84\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39moutflux \u001b[39m=\u001b[39m ynp1\u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39marea_outflux\n", - "\u001b[1;31mKeyboardInterrupt\u001b[0m: " - ] + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ "V = Ausgleichsbecken_class(1.,0.5,0.,10.,timestep=0.001)\n", - "V.set_initial_level(5.) \n", - "V.set_influx(1.)\n", - "V.set_outflux(0.)\n", + "V.set_initial_level(initial_level) \n", + "V.set_influx(initial_influx)\n", + "V.set_outflux(initial_outflux)\n", "\n", - "V.p0 = 0.\n", + "V.p0 = initial_pipeline_pressure\n", "\n", "outflux_vec = []\n", "level_vec = []\n", "\n", "t = 0\n", - "while V.level > 0.005:\n", + "while V.level > total_min_level:\n", " t = t+V.timestep\n", " V.e_RK_4()\n", " V.level = V.update_level(V.timestep)\n", " V.set_volume()\n", " outflux_vec.append(V.outflux)\n", " level_vec.append(V.level)\n", - " \n", + " if t > total_max_time:\n", + " break\n", + "\n", "plt.plot(level_vec)\n" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 31, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -83,47 +112,47 @@ "source": [ "V = Ausgleichsbecken_class(1.,0.1,0.,10.,timestep=0.001)\n", "\n", - "V.set_initial_level(5.) \n", - "V.set_influx(0.75)\n", - "V.set_outflux(0.)\n", + "V.set_initial_level(initial_level) \n", + "V.set_influx(initial_influx)\n", + "V.set_outflux(initial_outflux)\n", "\n", - "V.p0 = 0.\n", + "V.p0 = initial_pipeline_pressure\n", "\n", "outflux_vec = []\n", "level_vec = []\n", "\n", "t = 0\n", - "while V.level > 0.01:\n", + "while V.level > total_min_level:\n", " t = t+V.timestep\n", " V.e_RK_4()\n", " V.level = V.update_level(V.timestep)\n", " V.set_volume()\n", " outflux_vec.append(V.outflux)\n", " level_vec.append(V.level)\n", - " if t > 100:\n", + " if t > total_max_time:\n", " break\n", - " \n", + "\n", "plt.plot(level_vec)\n" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 18, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -137,24 +166,26 @@ "source": [ "V = Ausgleichsbecken_class(1.,0.9,0.,10.,timestep=0.001)\n", "\n", - "V.set_initial_level(10.) \n", - "V.set_influx(3.2)\n", - "V.set_outflux(0.)\n", + "V.set_initial_level(initial_level) \n", + "V.set_influx(initial_influx)\n", + "V.set_outflux(initial_outflux)\n", "\n", - "V.p0 = 0.\n", + "V.p0 = initial_pipeline_pressure\n", "\n", "outflux_vec = []\n", "level_vec = []\n", "\n", "t = 0\n", - "while V.level > 0.005:\n", + "while V.level > total_min_level:\n", " t = t+V.timestep\n", " V.e_RK_4()\n", " V.level = V.update_level(V.timestep)\n", " V.set_volume()\n", " outflux_vec.append(V.outflux)\n", " level_vec.append(V.level)\n", - " \n", + " if t > total_max_time:\n", + " break\n", + "\n", "plt.plot(level_vec)\n" ] } From 312f6b9532b48b20c1d0f7b9fafb878163bc1aef Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 20 Jun 2022 09:23:59 +0200 Subject: [PATCH 09/13] adapted FODE function in e-RK4 to (propably) be able to handle negative outflux velocities -> influx from pipeline --- Ausgleichsbecken.py | 2 +- Ausgleichsbecken_class_file.py | 1 + e-RK4-Test.ipynb | 39 ++++++++++++++++------------------ 3 files changed, 20 insertions(+), 22 deletions(-) diff --git a/Ausgleichsbecken.py b/Ausgleichsbecken.py index c4d9165..e887617 100644 --- a/Ausgleichsbecken.py +++ b/Ausgleichsbecken.py @@ -39,7 +39,7 @@ def get_p_halfstep(p0, p1): p_halfstep = (p0+p1)/2 def FODE_function(x, h, alpha, p, rho=1000., g=9.81): - f = x**2/h*alpha+g-p/(rho*h) + f = x*abs(x)/h*alpha+g-p/(rho*h) return f diff --git a/Ausgleichsbecken_class_file.py b/Ausgleichsbecken_class_file.py index 781cb51..1aac793 100644 --- a/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken_class_file.py @@ -67,6 +67,7 @@ class Ausgleichsbecken_class: def e_RK_4(self): + # Update to deal with non constant pipeline pressure! yn = self.outflux/self.area_outflux h = self.level dt = self.timestep diff --git a/e-RK4-Test.ipynb b/e-RK4-Test.ipynb index 9acfd87..a857ea4 100644 --- a/e-RK4-Test.ipynb +++ b/e-RK4-Test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 8, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -13,39 +13,39 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "# define constants\n", "initial_level = 5.\n", - "initial_influx = 3. \n", + "initial_influx = 0. \n", "initial_outflux = 0. \n", - "initial_pipeline_pressure = 0. \n", + "initial_pipeline_pressure = 10000. \n", "\n", "total_min_level = 0.01\n", - "total_max_time = 100\n", + "total_max_time = 150\n", "\n" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 10, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -83,22 +83,22 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 11, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -137,22 +137,22 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 12, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -191,11 +191,8 @@ } ], "metadata": { - "interpreter": { - "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" - }, "kernelspec": { - "display_name": "Python 3.8.13 ('DT_Slot_3')", + "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", "language": "python", "name": "python3" }, From 15780800727253d96164233f619a9526ba8c7227 Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 20 Jun 2022 11:22:26 +0200 Subject: [PATCH 10/13] created a function, that converts pressures --- functions/pressure_conversion.py | 77 ++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 functions/pressure_conversion.py diff --git a/functions/pressure_conversion.py b/functions/pressure_conversion.py new file mode 100644 index 0000000..96744c4 --- /dev/null +++ b/functions/pressure_conversion.py @@ -0,0 +1,77 @@ +# convert to Pa +def bar_to_pa(p): + return p*1e5 + +def mWS_to_pa(p): + return p*9.80665*1e3 + +def torr_to_pa(p): + return p*133.322 + +def atm_to_pa(p): + return p*101.325*1e3 + +def psi_to_pa(p): + return p*6894.8 + +# convert from Pa +def pa_to_bar(p): + return p*1e-5 + +def pa_to_mWS(p): + return p*1/(9.80665*1e3) + +def pa_to_torr(p): + return p/133.322 + +def pa_to_atm(p): + return p*1/(101.325*1e3) + + # converstion function + +def pa_to_psi(p): + return p/6894.8 + +def pressure_conversion(pressure, input_unit = 'bar', target_unit = 'Pa'): + p = pressure + if input_unit.lower() == 'bar': + p_pa = bar_to_pa(p) + elif input_unit.lower() == 'mws': + p_pa = mWS_to_pa(p) + elif input_unit.lower() == 'torr': + p_pa = torr_to_pa(p) + elif input_unit.lower() == 'atm': + p_pa = atm_to_pa(p) + elif input_unit.lower() == 'psi': + p_pa = psi_to_pa(p) + elif input_unit.lower() == 'pa': + p_pa = p + else: + raise Exception('Given input unit not recognised. \n Known units are: Pa, bar, mWs, Torr, atm, psi') + + if target_unit.lower() == 'bar': + return pa_to_bar(p_pa), target_unit + elif target_unit.lower() == 'mws': + return pa_to_mWS(p_pa), target_unit + elif target_unit.lower() == 'torr': + return pa_to_torr(p_pa), target_unit + elif target_unit.lower() == 'atm': + return pa_to_atm(p_pa), target_unit + elif target_unit.lower() =='psi': + return pa_to_psi(p_pa), target_unit + elif target_unit.lower() == 'pa': + return p_pa, target_unit + else: + raise Exception('Given target unit not recognised. \n Known units are: Pa, bar, mWs, Torr, atm, psi') + +# testing_pressure_conversion +if __name__ == '__main__': + p = 1 + + unit_dict = ['Pa','Bar','Torr','Atm','MWS','psi'] + + for input_unit in unit_dict: + for target_unit in unit_dict: + converted_p = pressure_conversion(p,input_unit,target_unit) + print(input_unit,target_unit) + print(converted_p) \ No newline at end of file From 981b0996737b9104fed15f947d4b52e3965ab1dc Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 20 Jun 2022 11:23:05 +0200 Subject: [PATCH 11/13] updated the units section, to display latex style text --- Ausgleichsbecken_class_file.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/Ausgleichsbecken_class_file.py b/Ausgleichsbecken_class_file.py index 1aac793..0608f8a 100644 --- a/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken_class_file.py @@ -1,12 +1,13 @@ from Ausgleichsbecken import FODE_function, get_h_halfstep, get_p_halfstep class Ausgleichsbecken_class: # units - area_unit = 'm^2' - area_outflux_unit = 'm^2' + area_unit = r'$\mathrm{m}^2$' + area_outflux_unit = r'$\mathrm{m}^2$' level_unit = 'm' - volume_unit = 'm^3' - flux_unit = 'm^3/s' + volume_unit = r'$\mathrm{m}^3$' + flux_unit = r'$\mathrm{m}^3/\mathrm{s}$' time_unit = 's' + pressure_unit = 'Pa' # init def __init__(self,area,outflux_area,level_min,level_max,timestep = 1): From f89ff4c1dc8315e2ffb5a6aead0c0c22acbfbffc Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 20 Jun 2022 11:34:32 +0200 Subject: [PATCH 12/13] incorporated the pressure conversion so that the FODE function always gets pressure in Pa --- Ausgleichsbecken_class_file.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Ausgleichsbecken_class_file.py b/Ausgleichsbecken_class_file.py index 0608f8a..06d1122 100644 --- a/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken_class_file.py @@ -1,4 +1,5 @@ from Ausgleichsbecken import FODE_function, get_h_halfstep, get_p_halfstep +from functions.pressure_conversion import pressure_conversion class Ausgleichsbecken_class: # units area_unit = r'$\mathrm{m}^2$' @@ -72,8 +73,8 @@ class Ausgleichsbecken_class: yn = self.outflux/self.area_outflux h = self.level dt = self.timestep - p = self.p0 - p_hs = self.p0 + p,_ = pressure_conversion(self.p0,self.pressure_unit,'Pa') + p_hs,_ = pressure_conversion(self.p0,self.pressure_unit,'Pa') alpha = (self.area_outflux/self.area-1) h_hs = self.update_level(dt/2) Y1 = yn From 4583d59f0f98b17361496a6538ccf58d7e812c8f Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 20 Jun 2022 11:55:32 +0200 Subject: [PATCH 13/13] kinda working version of Ausgleichbecken code for static pipeline pressure --- .gitignore | 1 + Ausgleichsbecken_class_file.py | 6 +- Main_Program.ipynb | 149 ++++++++++++++++++++++++++++++++- 3 files changed, 149 insertions(+), 7 deletions(-) diff --git a/.gitignore b/.gitignore index 95fdff4..bbdd72c 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,4 @@ functions/__pycache__/ .vscode/settings.json __pycache__/Ausgleichsbecken_class_file.cpython-38.pyc __pycache__/Ausgleichsbecken.cpython-38.pyc +__pycache__/functions.cpython-38.pyc diff --git a/Ausgleichsbecken_class_file.py b/Ausgleichsbecken_class_file.py index 06d1122..a6e2500 100644 --- a/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken_class_file.py @@ -73,12 +73,12 @@ class Ausgleichsbecken_class: yn = self.outflux/self.area_outflux h = self.level dt = self.timestep - p,_ = pressure_conversion(self.p0,self.pressure_unit,'Pa') - p_hs,_ = pressure_conversion(self.p0,self.pressure_unit,'Pa') + p,_ = pressure_conversion(self.initial_pressure,self.pressure_unit,'Pa') + p_hs,_ = pressure_conversion(self.initial_pressure,self.pressure_unit,'Pa') alpha = (self.area_outflux/self.area-1) h_hs = self.update_level(dt/2) Y1 = yn - Y2 = yn + dt/2*FODE_function(Y1, h, alpha, self.p0) + Y2 = yn + dt/2*FODE_function(Y1, h, alpha, self.initial_pressure) Y3 = yn + dt/2*FODE_function(Y2, h_hs, alpha, p_hs) Y4 = yn + dt*FODE_function(Y3, h_hs, alpha, p_hs) ynp1 = yn + dt/6*(FODE_function(Y1, h, alpha, p)+2*FODE_function(Y2, h_hs, alpha, p_hs)+ \ diff --git a/Main_Program.ipynb b/Main_Program.ipynb index 3557ac5..b266228 100644 --- a/Main_Program.ipynb +++ b/Main_Program.ipynb @@ -2,26 +2,167 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "import numpy as np\n", + "from Ausgleichsbecken_class_file import Ausgleichsbecken_class\n", + "import matplotlib.pyplot as plt\n", + "from functions.pressure_conversion import pressure_conversion" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# define constants\n", + "initial_level = 5. # m\n", + "initial_influx = 0. # m³/s\n", + "initial_outflux = 0. # m³/s\n", + "initial_pipeline_pressure = 1.\n", + "initial_pressure_unit = 'bar'\n", + "conversion_pressure_unit = 'mWS'\n", + "\n", + "area_base = 1. # m²\n", + "area_outflux = 0.5 # m²\n", + "critical_level_low = 0. # m\n", + "critical_level_high = 10. # m\n", + "simulation_timestep = 0.001 # s\n", + "\n", + "# for while loop\n", + "total_min_level = 0.01 # m\n", + "total_max_time = 150 # s" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c7ff9cd7c3ae4d21a32d833650fa73a3", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib widget\n", + "\n", + "V = Ausgleichsbecken_class(area_base, area_outflux, critical_level_low, critical_level_high,simulation_timestep)\n", + "V.set_initial_level(initial_level) \n", + "V.set_influx(initial_influx)\n", + "V.set_outflux(initial_outflux)\n", + "\n", + "V.initial_pressure, V.pressure_unit = pressure_conversion(initial_pipeline_pressure,input_unit = initial_pressure_unit, target_unit = conversion_pressure_unit)\n", + "\n", + "time_vec = np.arange(0,total_max_time,simulation_timestep)\n", + "outflux_vec = np.empty_like(time_vec)\n", + "outflux_vec[0] = initial_outflux\n", + "level_vec = np.empty_like(time_vec)\n", + "level_vec[0] = initial_level\n", + " \n", + "i_max = -1\n", + "\n", + "for i in range(np.size(time_vec)-1):\n", + " V.e_RK_4()\n", + " V.level = V.update_level(V.timestep)\n", + " V.set_volume()\n", + " outflux_vec[i+1] = V.outflux\n", + " level_vec[i+1] = V.level\n", + " if V.level < total_min_level:\n", + " i_max = i\n", + " break\n", + "\n", + "\n", + "fig1, (ax1, ax2, ax3) = plt.subplots(3, 1)\n", + "fig1.set_figheight(10)\n", + "fig1.suptitle('Ausgleichsbecken')\n", + "\n", + "ax1.plot(time_vec[:i_max],level_vec[:i_max], label='Water level')\n", + "ax1.set_ylabel(r'$h$ ['+V.level_unit+']')\n", + "ax1.set_xlabel(r'$t$ ['+V.time_unit+']')\n", + "ax1.legend()\n", + "\n", + "ax2.plot(time_vec[:i_max],outflux_vec[:i_max], label='Outflux')\n", + "ax2.set_ylabel(r'$Q_{out}$ ['+V.flux_unit+']')\n", + "ax2.set_xlabel(r'$t$ ['+V.time_unit+']')\n", + "ax2.legend()\n", + "\n", + "# plt.subplots_adjust(left=0.2, bottom=0.2)\n", + "ax3.set_axis_off()\n", + "cell_text = np.array([[initial_level, V.level_unit], \\\n", + " [initial_influx, V.flux_unit], \\\n", + " [initial_outflux, V.flux_unit], \\\n", + " [round(V.initial_pressure,2), V.pressure_unit], \\\n", + " [simulation_timestep, V.time_unit], \\\n", + " [area_base, V.area_unit], \\\n", + " [area_outflux, V.area_unit]])\n", + "\n", + "row_labels =['initial_level', \\\n", + " 'initial_influx', \\\n", + " 'initial_outflux', \\\n", + " 'initial_pipeline_pressure', \\\n", + " 'simulation_timestep', \\\n", + " 'area_base', \\\n", + " 'area_outflux']\n", + "\n", + "plt.table(cellText=cell_text, \\\n", + " cellLoc='center', \\\n", + " colWidths=[0.3,0.1,0.3], \\\n", + " rowLabels=row_labels, \\\n", + " loc = 1, \\\n", + " rowLoc='left', \\\n", + " fontsize = 15.)\n", + "\n", + "fig1.tight_layout() " + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('DT_Slot_3')", + "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", "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.8.13" }, "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" + "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" } } },