From 0de946f8aceed0b7e4d6db72f872f725f3ad4a77 Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 25 Jul 2022 11:51:02 +0200 Subject: [PATCH 01/11] code cleanup and commenting I --- .../Ausgleichsbecken_class_file.py | 102 +++++++++++++----- Ausgleichsbecken/Ausgleichsbecken_test.ipynb | 14 +-- functions/pressure_conversion.py | 23 ++-- 3 files changed, 99 insertions(+), 40 deletions(-) diff --git a/Ausgleichsbecken/Ausgleichsbecken_class_file.py b/Ausgleichsbecken/Ausgleichsbecken_class_file.py index b00d957..0092846 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken/Ausgleichsbecken_class_file.py @@ -1,3 +1,4 @@ +from logging import exception import numpy as np #importing pressure conversion function @@ -8,8 +9,19 @@ parent = os.path.dirname(current) sys.path.append(parent) from functions.pressure_conversion import pressure_conversion -def FODE_function(x, h, alpha, p, rho=1000., g=9.81): - f = x*abs(x)/h*alpha+g-p/(rho*h) +def FODE_function(x,h,A,A_a,p,rho,g): + # (FODE ... first order differential equation) + # based on the outflux formula by Andreas Malcherek + # https://www.youtube.com/watch?v=8HO2LwqOhqQ + # adapted for a pressurized pipeline into which the reservoir effuses + # and flow direction + # x ... effusion velocity + # h ... level in the reservoir + # A_a ... Outflux_Area + # A ... Reservoir_Area + # g ... gravitational acceleration + # rho ... density of the liquid in the reservoir + f = x*abs(x)/h*(A_a/A-1)+g-p/(rho*h) return f @@ -19,67 +31,84 @@ class Ausgleichsbecken_class: # units are used to label graphs and print units are used to have a bearable format when using pythons print() area_unit = r'$\mathrm{m}^2$' area_outflux_unit = r'$\mathrm{m}^2$' + density_unit = r'$\mathrm{kg}/\mathrm{m}^3$' flux_unit = r'$\mathrm{m}^3/\mathrm{s}$' level_unit = 'm' + pressure_unit = 'Pa' time_unit = 's' velocity_unit = r'$\mathrm{m}/\mathrm{s}$' volume_unit = r'$\mathrm{m}^3$' area_unit_print = 'm²' area_outflux_unit_print = 'm²' + density_unit_print = 'kg/m³' flux_unit_print = 'm³/s' level_unit_print = 'm' time_unit_print = 's' + pressure_unit_print = '--' # will be set by .set_pressure() method velocity_unit_print = 'm/s' volume_unit_print = 'm³' - g = 9.81 # m/s² - rho = 1000 # kg/m³ + g = 9.81 # m/s² gravitational acceleration + # init - def __init__(self,area,outflux_area,level_min = 0,level_max = np.inf ,timestep = 1): + def __init__(self,area,outflux_area,level_min = 0,level_max = np.inf ,timestep = 1,rho = 1000): self.area = area # base area of the rectangular structure self.area_outflux = outflux_area # area of the outlet towards the pipeline + self.density = rho # density of the liquid in the system 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 # initialize for get_info - self.level = "--" self.influx = "--" + self.level = "--" self.outflux = "--" self.volume = "--" # setter - def set_volume(self): + def update_volume(self): + # sets volume in reservoir based on self.level self.volume = self.level*self.area def set_initial_level(self,initial_level): - self.level = initial_level - self.set_volume() + # sets the level in the reservoir and should only be called during initialization + if self.level == '--': + self.level = initial_level + self.update_volume() + else: + raise Exception('Initial level was already set once. Use the .update_level(self,timestep) method to update level based on net flux.') def set_influx(self,influx): + # sets influx to the reservoir in m³/s + # positive influx means that liquid flows into the reservoir self.influx = influx def set_outflux(self,outflux): - self.outflux = outflux - self.outflux_vel = outflux/self.area_outflux + # sets outflux to the reservoir in m³/s + # positive outflux means that liquid flows out of reservoir the reservoir + self.outflux = outflux - def set_pressure(self,pressure,pressure_unit,display_pressure_unit): + def set_pressure(self,pressure,display_pressure_unit): + # sets the static pressure present at the outlet of the reservoir + # units are used to convert and display the pressure self.pressure = pressure - self.pressure_unit = pressure_unit self.pressure_unit_print = display_pressure_unit - def set_steady_state(self,ss_influx,ss_level,pressure_unit,display_pressure_unit): + def set_steady_state(self,ss_influx,ss_level,display_pressure_unit): + # find the steady state (ss) condition in which the net flux is zero + # set pressure acting on the outflux so that the level stays constant ss_outflux = ss_influx ss_outflux_vel = ss_outflux/self.area_outflux - ss_pressure = self.rho*self.g*ss_level-ss_outflux_vel**2*self.rho/2 + ss_pressure = self.density*self.g*ss_level-ss_outflux_vel**2*self.density/2 self.set_initial_level(ss_level) self.set_influx(ss_influx) self.set_outflux(ss_outflux) - self.set_pressure(ss_pressure,pressure_unit,display_pressure_unit) + self.set_pressure(ss_pressure,display_pressure_unit) + # getter def get_info(self, full = False): new_line = '\n' @@ -101,6 +130,7 @@ class Ausgleichsbecken_class: f"Current outflux vel = {round(self.outflux_vel,3):<10} {self.velocity_unit_print} {new_line}" f"Current pipe pressure = {round(p,3):<10} {self.pressure_unit_print} {new_line}" f"Simulation timestep = {self.timestep:<10} {self.time_unit_print} {new_line}" + f"Density of liquid = {self.density:<10} {self.density_unit_print} {new_line}" f"----------------------------- {new_line}") else: # :<10 pads the self.value to be 10 characters wide @@ -116,9 +146,27 @@ class Ausgleichsbecken_class: print(print_str) + def get_current_level(self): + return self.level + + def get_current_influx(self): + return self.influx + + def get_current_outflux(self): + return self.outflux + + def get_current_volume(self): + return self.volume + + def get_current_pressure(self): + return self.pressure + + # methods def update_level(self,timestep): + # update level based on net flux and timestep by calculating the volume change in + # the timestep and the converting the new volume to a level by assuming a cuboid reservoir net_flux = self.influx-self.outflux delta_V = net_flux*timestep new_level = (self.volume+delta_V)/self.area @@ -127,21 +175,25 @@ class Ausgleichsbecken_class: def e_RK_4(self): # update outflux and outflux velocity based on current pipeline pressure and waterlevel in reservoir - yn = self.outflux_vel + yn = self.outflux/self.area_outflux # outflux velocity h = self.level dt = self.timestep p = self.pressure - # assume constant pipeline pressure during timestep (see comments in main_programm) + # assume constant pipeline pressure during timestep + # e_RK_4 timestep is way smalle than timestep of characteristic method, so this should be a valid approx. + # (furthermore I have no idea how to approximate p_hs otherwise :/ ) p_hs = self.pressure - alpha = (self.area_outflux/self.area-1) + A_a = self.area_outflux + A = self.area h_hs = self.update_level(dt/2) + rho = self.density + g = self.g # explicit 4 step Runge Kutta Y1 = yn - Y2 = yn + dt/2*FODE_function(Y1, h, alpha, self.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)+ \ - 2*FODE_function(Y3, h_hs, alpha, p_hs)+ FODE_function(Y4, h, alpha, p)) + Y2 = yn + dt/2*FODE_function(Y1,h,A,A_a,self.pressure,rho,g) + Y3 = yn + dt/2*FODE_function(Y2,h_hs,A,A_a,p_hs,rho,g) + Y4 = yn + dt*FODE_function(Y3,h_hs,A,A_a,p_hs,rho,g) + ynp1 = yn + dt/6*(FODE_function(Y1,h,A,A_a,p,rho,g)+2*FODE_function(Y2,h_hs,A,A_a,p_hs,rho,g)+ \ + 2*FODE_function(Y3,h_hs,A,A_a,p_hs,rho,g)+ FODE_function(Y4,h,A,A_a,p,rho,g)) - self.outflux_vel = ynp1 self.outflux = ynp1*self.area_outflux diff --git a/Ausgleichsbecken/Ausgleichsbecken_test.ipynb b/Ausgleichsbecken/Ausgleichsbecken_test.ipynb index eea80ce..4f72ad4 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_test.ipynb +++ b/Ausgleichsbecken/Ausgleichsbecken_test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 12, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -76,7 +76,7 @@ " V.pressure = pressure_vec[i]\n", " V.e_RK_4()\n", " V.level = V.update_level(V.timestep)\n", - " V.set_volume()\n", + " V.update_volume()\n", " outflux_vec[i+1] = V.outflux\n", " level_vec[i+1] = V.level\n", " if V.level < total_min_level:\n", @@ -87,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -141,7 +141,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('DT_Slot_3')", + "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", "language": "python", "name": "python3" }, @@ -160,7 +160,7 @@ "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" + "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" } } }, diff --git a/functions/pressure_conversion.py b/functions/pressure_conversion.py index 96744c4..d4a91f9 100644 --- a/functions/pressure_conversion.py +++ b/functions/pressure_conversion.py @@ -32,7 +32,7 @@ def pa_to_atm(p): def pa_to_psi(p): return p/6894.8 -def pressure_conversion(pressure, input_unit = 'bar', target_unit = 'Pa'): +def pressure_conversion(pressure, input_unit = 'bar', target_unit = 'Pa', return_unit = False): p = pressure if input_unit.lower() == 'bar': p_pa = bar_to_pa(p) @@ -50,20 +50,27 @@ def pressure_conversion(pressure, input_unit = 'bar', target_unit = 'Pa'): 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 + return_vec = [pa_to_bar(p_pa), target_unit] elif target_unit.lower() == 'mws': - return pa_to_mWS(p_pa), target_unit + return_vec = [pa_to_mWS(p_pa), target_unit] elif target_unit.lower() == 'torr': - return pa_to_torr(p_pa), target_unit + return_vec = [pa_to_torr(p_pa), target_unit] elif target_unit.lower() == 'atm': - return pa_to_atm(p_pa), target_unit + return_vec = [pa_to_atm(p_pa), target_unit] elif target_unit.lower() =='psi': - return pa_to_psi(p_pa), target_unit + return_vec = [pa_to_psi(p_pa), target_unit] elif target_unit.lower() == 'pa': - return p_pa, target_unit + return_vec = [p_pa, target_unit] else: raise Exception('Given target unit not recognised. \n Known units are: Pa, bar, mWs, Torr, atm, psi') + if return_unit == True: + # return with pressure unit + return return_vec + else: + # return without pressure unit + return return_vec[0] + # testing_pressure_conversion if __name__ == '__main__': p = 1 @@ -72,6 +79,6 @@ if __name__ == '__main__': for input_unit in unit_dict: for target_unit in unit_dict: - converted_p = pressure_conversion(p,input_unit,target_unit) + converted_p = pressure_conversion(p,input_unit,target_unit,return_unit=False) print(input_unit,target_unit) print(converted_p) \ No newline at end of file From ac8bfdb7c6801edcb32a0c54a42daba747e90c3e Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 25 Jul 2022 15:59:46 +0200 Subject: [PATCH 02/11] further code cleanup --- .../Ausgleichsbecken_class_file.py | 37 +-- ... Ausgleichsbecken_test_steady_state.ipynb} | 30 ++- .../Druckrohrleitung_class_file.py | 165 ++++++------ Druckrohrleitung/Druckrohrleitung_test.ipynb | 237 ------------------ .../Druckrohrleitung_test_steady_state.ipynb | 202 +++++++++++++++ .../{ => old}/regler_test_optimierung.ipynb | 0 Turbinen/Turbinen_class_file.py | 8 +- Turbinen/Turbinen_test.ipynb | 167 +++++++----- Untertweng.ipynb | 40 +-- 9 files changed, 448 insertions(+), 438 deletions(-) rename Ausgleichsbecken/{Ausgleichsbecken_test.ipynb => Ausgleichsbecken_test_steady_state.ipynb} (87%) delete mode 100644 Druckrohrleitung/Druckrohrleitung_test.ipynb create mode 100644 Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb rename Regler/{ => old}/regler_test_optimierung.ipynb (100%) diff --git a/Ausgleichsbecken/Ausgleichsbecken_class_file.py b/Ausgleichsbecken/Ausgleichsbecken_class_file.py index 0092846..e8242d6 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken/Ausgleichsbecken_class_file.py @@ -69,15 +69,11 @@ class Ausgleichsbecken_class: # setter - def update_volume(self): - # sets volume in reservoir based on self.level - self.volume = self.level*self.area - def set_initial_level(self,initial_level): # sets the level in the reservoir and should only be called during initialization if self.level == '--': - self.level = initial_level - self.update_volume() + self.level = initial_level + self.volume = self.update_volume() else: raise Exception('Initial level was already set once. Use the .update_level(self,timestep) method to update level based on net flux.') @@ -91,28 +87,33 @@ class Ausgleichsbecken_class: # positive outflux means that liquid flows out of reservoir the reservoir self.outflux = outflux - def set_pressure(self,pressure,display_pressure_unit): + def set_initial_pressure(self,pressure,display_pressure_unit): # sets the static pressure present at the outlet of the reservoir # units are used to convert and display the pressure self.pressure = pressure self.pressure_unit_print = display_pressure_unit + def set_pressure(self,pressure): + # sets the static pressure present at the outlet of the reservoir + # units are used to convert and display the pressure + self.pressure = pressure + def set_steady_state(self,ss_influx,ss_level,display_pressure_unit): - # find the steady state (ss) condition in which the net flux is zero - # set pressure acting on the outflux so that the level stays constant + # set the steady state (ss) condition in which the net flux is zero + # set pressure acting on the outflux area so that the level stays constant ss_outflux = ss_influx ss_outflux_vel = ss_outflux/self.area_outflux ss_pressure = self.density*self.g*ss_level-ss_outflux_vel**2*self.density/2 - self.set_initial_level(ss_level) self.set_influx(ss_influx) + self.set_initial_level(ss_level) + self.set_initial_pressure(ss_pressure,display_pressure_unit) self.set_outflux(ss_outflux) - self.set_pressure(ss_pressure,display_pressure_unit) # getter def get_info(self, full = False): new_line = '\n' - p,_ = pressure_conversion(self.pressure,self.pressure_unit,self.pressure_unit_print) + p = pressure_conversion(self.pressure,self.pressure_unit,self.pressure_unit_print) if full == True: @@ -164,6 +165,7 @@ class Ausgleichsbecken_class: # methods + def update_level(self,timestep): # update level based on net flux and timestep by calculating the volume change in # the timestep and the converting the new volume to a level by assuming a cuboid reservoir @@ -172,8 +174,12 @@ class Ausgleichsbecken_class: new_level = (self.volume+delta_V)/self.area return new_level + def update_volume(self): + # sets volume in reservoir based on self.level + return self.level*self.area - def e_RK_4(self): + + def timestep_reservoir_evolution(self): # update outflux and outflux velocity based on current pipeline pressure and waterlevel in reservoir yn = self.outflux/self.area_outflux # outflux velocity h = self.level @@ -196,4 +202,7 @@ class Ausgleichsbecken_class: ynp1 = yn + dt/6*(FODE_function(Y1,h,A,A_a,p,rho,g)+2*FODE_function(Y2,h_hs,A,A_a,p_hs,rho,g)+ \ 2*FODE_function(Y3,h_hs,A,A_a,p_hs,rho,g)+ FODE_function(Y4,h,A,A_a,p,rho,g)) - self.outflux = ynp1*self.area_outflux + self.outflux = ynp1*self.area_outflux + self.level = self.update_level(dt) + self.volume = self.update_volume() + diff --git a/Ausgleichsbecken/Ausgleichsbecken_test.ipynb b/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb similarity index 87% rename from Ausgleichsbecken/Ausgleichsbecken_test.ipynb rename to Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb index 4f72ad4..8838088 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_test.ipynb +++ b/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -56,29 +56,27 @@ "# V.set_initial_level(initial_level) \n", "# V.set_influx(initial_influx)\n", "# V.set_outflux(initial_outflux)\n", - "# converted_pressure,_ = pressure_conversion(initial_pipeline_pressure,input_unit = initial_pressure_unit, target_unit = 'Pa')\n", + "# V.set_initial_pressure(pressure_conversion(initial_pipeline_pressure,input_unit = initial_pressure_unit, target_unit = 'Pa'),conversion_pressure_unit)\n", "# V.pressure = converted_pressure\n", - "V.set_steady_state(initial_influx,initial_level,initial_pressure_unit,conversion_pressure_unit)\n", + "V.set_steady_state(initial_influx,initial_level,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] = V.outflux\n", + "outflux_vec[0] = V.get_current_outflux()\n", "level_vec = np.empty_like(time_vec)\n", - "level_vec[0] = V.level\n", + "level_vec[0] = V.get_current_level()\n", "\n", "# pressure_vec = np.full_like(time_vec,converted_pressure)*((np.sin(time_vec)+1)*np.exp(-time_vec/50))\n", - "pressure_vec = np.full_like(time_vec,V.pressure)\n", + "pressure_vec = np.full_like(time_vec,V.get_current_pressure())\n", " \n", "i_max = -1\n", "\n", "for i in range(np.size(time_vec)-1):\n", " # update to include p_halfstep\n", - " V.pressure = pressure_vec[i]\n", - " V.e_RK_4()\n", - " V.level = V.update_level(V.timestep)\n", - " V.update_volume()\n", - " outflux_vec[i+1] = V.outflux\n", - " level_vec[i+1] = V.level\n", + " V.set_pressure(pressure_vec[i])\n", + " V.timestep_reservoir_evolution()\n", + " outflux_vec[i+1] = V.get_current_outflux()\n", + " level_vec[i+1] = V.get_current_level()\n", " if V.level < total_min_level:\n", " i_max = i\n", " break\n", @@ -87,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -106,7 +104,7 @@ "ax2.set_xlabel(r'$t$ ['+V.time_unit+']')\n", "ax2.legend()\n", "\n", - "ax3.plot(time_vec[:i_max],pressure_conversion(pressure_vec[:i_max],'Pa',conversion_pressure_unit)[0], label='Pipeline pressure at reservoir')\n", + "ax3.plot(time_vec[:i_max],pressure_conversion(pressure_vec[:i_max],'Pa',conversion_pressure_unit), label='Pipeline pressure at reservoir')\n", "ax3.set_ylabel(r'$p_{pipeline}$ ['+conversion_pressure_unit+']')\n", "ax3.set_xlabel(r'$t$ ['+V.time_unit+']')\n", "ax3.legend()\n", diff --git a/Druckrohrleitung/Druckrohrleitung_class_file.py b/Druckrohrleitung/Druckrohrleitung_class_file.py index fd5a15f..df9a3c1 100644 --- a/Druckrohrleitung/Druckrohrleitung_class_file.py +++ b/Druckrohrleitung/Druckrohrleitung_class_file.py @@ -1,51 +1,40 @@ import numpy as np -#importing pressure conversion function -import sys -import os -current = os.path.dirname(os.path.realpath(__file__)) -parent = os.path.dirname(current) -sys.path.append(parent) -from functions.pressure_conversion import pressure_conversion - - - - class Druckrohrleitung_class: # units - acceleration_unit = r'$\mathrm{m}/\mathrm{s}^2$' - angle_unit = 'rad' - area_unit = r'$\mathrm{m}^2$' - density_unit = r'$\mathrm{kg}/\mathrm{m}^3$' - flux_unit = r'$\mathrm{m}^3/\mathrm{s}$' - length_unit = 'm' - time_unit = 's' - velocity_unit = r'$\mathrm{m}/\mathrm{s}$' # for flux and pressure propagation - volume_unit = r'$\mathrm{m}^3$' + acceleration_unit = r'$\mathrm{m}/\mathrm{s}^2$' + angle_unit = 'rad' + area_unit = r'$\mathrm{m}^2$' + density_unit = r'$\mathrm{kg}/\mathrm{m}^3$' + flux_unit = r'$\mathrm{m}^3/\mathrm{s}$' + length_unit = 'm' + pressure_unit = 'Pa' + time_unit = 's' + velocity_unit = r'$\mathrm{m}/\mathrm{s}$' # for flux and pressure propagation + volume_unit = r'$\mathrm{m}^3$' - acceleration_unit_print = 'm/s²' - angle_unit_print = 'rad' - area_unit_print = 'm²' - density_unit_print = 'kg/m³' - flux_unit_print = 'm³/s' - length_unit_print = 'm' - time_unit_print = 's' - velocity_unit_print = 'm/s' # for flux and pressure propagation - volume_unit_print = 'm³' - + acceleration_unit_print = 'm/s²' + angle_unit_print = 'rad' + area_unit_print = 'm²' + density_unit_print = 'kg/m³' + flux_unit_print = 'm³/s' + length_unit_print = 'm' + time_unit_print = 's' + velocity_unit_print = 'm/s' # for flux and pressure propagation + volume_unit_print = 'm³' # init def __init__(self,total_length,diameter,number_segments,pipeline_angle,Darcy_friction_factor,rho=1000,g=9.81): - self.length = total_length - self.dia = diameter - self.n_seg = number_segments - self.angle = pipeline_angle - self.f_D = Darcy_friction_factor # = Rohrreibungszahl oder flow coefficient - self.rho = rho - self.g = g + self.length = total_length # total length of the pipeline + self.dia = diameter # diameter of the pipeline + self.n_seg = number_segments # number of segments for the method of characteristics + self.angle = pipeline_angle # angle of the pipeline + self.f_D = Darcy_friction_factor # = Rohrreibungszahl oder flow coefficient + self.density = rho # density of the liquid in the pipeline + self.g = g # gravitational acceleration - self.dx = total_length/number_segments - self.l_vec = np.arange(0,(number_segments+1)*self.dx,self.dx) + self.dx = total_length/number_segments # length of each segment + self.l_vec = np.arange(0,(number_segments+1),1)*self.dx # vector giving the distance from each node to the start of the pipeline # initialize for get_info method self.c = '--' @@ -53,32 +42,32 @@ class Druckrohrleitung_class: # setter def set_pressure_propagation_velocity(self,c): - self.c = c - self.dt = self.dx/c + self.c = c # propagation velocity of the pressure wave + self.dt = self.dx/c # timestep derived from c, demanded by the method of characteristics def set_number_of_timesteps(self,number_timesteps): - self.nt = number_timesteps + self.nt = number_timesteps # number of timesteps if self.c == '--': raise Exception('Please set the pressure propagation velocity before setting the number of timesteps.') else: self.t_vec = np.arange(0,self.nt*self.dt,self.dt) - def set_initial_pressure(self,pressure,pressure_unit,display_pressure_unit): - if np.size(pressure) == 1: + def set_initial_pressure(self,pressure): + # initialize the pressure distribution in the pipeline + if np.size(pressure) == 1: self.p0 = np.full_like(self.l_vec,pressure) elif np.size(pressure) == np.size(self.l_vec): self.p0 = pressure else: raise Exception('Unable to assign initial pressure. Input has to be of size 1 or' + np.size(self.l_vec)) - self.pressure_unit = pressure_unit - self.pressure_unit_print = display_pressure_unit #initialize the vectors in which the old and new pressures are stored for the method of characteristics - self.p_old = self.p0.copy() - self.p = np.empty_like(self.p_old) + self.p_old = self.p0.copy() + self.p = self.p0.copy() def set_initial_flow_velocity(self,velocity): - if np.size(velocity) == 1: + # initialize the velocity distribution in the pipeline + if np.size(velocity) == 1: self.v0 = np.full_like(self.l_vec,velocity) elif np.size(velocity) == np.size(self.l_vec): self.v0 = velocity @@ -86,35 +75,51 @@ class Druckrohrleitung_class: raise Exception('Unable to assign initial velocity. Input has to be of size 1 or' + np.size(self.l_vec)) #initialize the vectors in which the old and new velocities are stored for the method of characteristics - self.v_old = self.v0.copy() - self.v = np.empty_like(self.v_old) + self.v_old = self.v0.copy() + self.v = self.v0.copy() - def set_boundary_conditions_next_timestep(self,v_reservoir,p_reservoir,v_turbine): - rho = self.rho + def set_boundary_conditions_next_timestep(self,p_reservoir,v_turbine): + # derived from the method of characteristics, one can set the boundary conditions for the pressures and flow velocities at the reservoir and the turbine + # the boundary velocity at the turbine is specified by the flux through the turbine or an external boundary condition + # the pressure at the turbine will be calculated using the forward characteristic + # the boundary pressure at the reservoir is specified by the level in the reservoir of an external boundary condition + # the velocity at the reservoir will be calculated using the backward characteristic + + # constants for a cleaner formula + rho = self.density c = self.c f_D = self.f_D dt = self.dt D = self.dia g = self.g alpha = self.angle - p_old = self.p_old[-2] # @ second to last node (the one before the turbine) - v_old = self.v_old[-2] # @ second to last node (the one before the turbine) - self.v_boundary_res = v_reservoir # at new timestep + p_old_tur = self.p_old[-2] # @ second to last node (the one before the turbine) + v_old_tur = self.v_old[-2] # @ second to last node (the one before the turbine) + p_old_res = self.p_old[1] # @ second node (the one after the reservoir) + v_old_res = self.v_old[1] # @ second node (the one after the reservoir) + # set the boundary conditions derived from reservoir and turbine self.v_boundary_tur = v_turbine # at new timestep - self.p_boundary_res = p_reservoir - self.p_boundary_tur = p_old-rho*c*(v_turbine-v_old)+rho*c*dt*g*np.sin(alpha)-f_D*rho*c*dt/(2*D)*abs(v_old)*v_old + self.p_boundary_res = p_reservoir # at new timestep + # calculate the missing boundary conditions + self.v_boundary_res = v_old_res+1/(rho*c)*(p_reservoir-p_old_res)+dt*g*np.sin(alpha)-f_D*dt/(2*D)*abs(v_old_res)*v_old_res + self.p_boundary_tur = p_old_tur-rho*c*(v_turbine-v_old_tur)+rho*c*dt*g*np.sin(alpha)-f_D*rho*c*dt/(2*D)*abs(v_old_tur)*v_old_tur + + # write boundary conditions to the velocity/pressure vectors of the next timestep self.v[0] = self.v_boundary_res.copy() self.v[-1] = self.v_boundary_tur.copy() self.p[0] = self.p_boundary_res.copy() self.p[-1] = self.p_boundary_tur.copy() - def set_steady_state(self,ss_flux,ss_level_reservoir,pl_vec,h_vec,pressure_unit,display_pressure_unit): + def set_steady_state(self,ss_flux,ss_level_reservoir,pl_vec,h_vec): + # set the pressure and velocity distributions, that allow a constant flow of water from the (steady-state) reservoir to the (steady-state) turbine + # the flow velocity is given by the constant flow through the pipe ss_v0 = np.full(self.n_seg+1,ss_flux/(self.dia**2/4*np.pi)) - ss_pressure = (self.rho*self.g*(ss_level_reservoir+h_vec)-ss_v0**2*self.rho/2)-(self.f_D*pl_vec/self.dia*self.rho/2*ss_v0**2) + # the static pressure is given by the hydrostatic pressure, corrected for friction losses and dynamic pressure + ss_pressure = (self.density*self.g*(ss_level_reservoir+h_vec)-ss_v0**2*self.density/2)-(self.f_D*pl_vec/self.dia*self.density/2*ss_v0**2) self.set_initial_flow_velocity(ss_v0) - self.set_initial_pressure(ss_pressure,pressure_unit,display_pressure_unit) + self.set_initial_pressure(ss_pressure) # getter def get_info(self): @@ -142,30 +147,27 @@ class Druckrohrleitung_class: f"Velocity and pressure distribution are vectors and are accessible by the .v and .p attribute of the pipeline object") print(print_str) - - def get_boundary_conditions_next_timestep(self): - print('The pressure at the reservoir for the next timestep is', '\n', \ - pressure_conversion(self.p_boundary_res,self.pressure_unit,self.pressure_unit_print), '\n', \ - 'The velocity at the reservoir for the next timestep is', '\n', \ - self.v_boundary_res, self.velocity_unit_print, '\n', \ - 'The pressure at the turbine for the next timestep is', '\n', \ - pressure_conversion(self.p_boundary_tur,self.pressure_unit,self.pressure_unit_print), '\n', \ - 'The velocity at the turbine for the next timestep is', '\n', \ - self.v_boundary_tur, self.velocity_unit_print) + def get_current_pressure_distribution(self): + return self.p + def get_current_velocity_distribution(self): + return self.v def timestep_characteristic_method(self): - #number of nodes - nn = self.n_seg+1 - rho = self.rho - c = self.c - f_D = self.f_D - dt = self.dt - D = self.dia - g = self.g - alpha = self.angle + # use the method of characteristics to calculate the pressure and velocities at all nodes except the boundary ones + # they are set with the .set_boundary_conditions_next_timestep() method beforehand + + nn = self.n_seg+1 # number of nodes + rho = self.density # density of liquid + c = self.c # pressure propagation velocity + f_D = self.f_D # Darcy friction coefficient + dt = self.dt # timestep + D = self.dia # pipeline diametet + g = self.g # graviational acceleration + alpha = self.angle # pipeline angle + # Vectorize this loop? for i in range(1,nn-1): self.v[i] = 0.5*(self.v_old[i+1]+self.v_old[i-1])-0.5/(rho*c)*(self.p_old[i+1]-self.p_old[i-1]) \ +dt*g*np.sin(alpha)-f_D*dt/(4*D)*(abs(self.v_old[i+1])*self.v_old[i+1]+abs(self.v_old[i-1])*self.v_old[i-1]) @@ -173,5 +175,8 @@ class Druckrohrleitung_class: self.p[i] = 0.5*(self.p_old[i+1]+self.p_old[i-1]) - 0.5*rho*c*(self.v_old[i+1]-self.v_old[i-1]) \ +f_D*rho*c*dt/(4*D)*(abs(self.v_old[i+1])*self.v_old[i+1]-abs(self.v_old[i-1])*self.v_old[i-1]) + # prepare for next call + # use .copy() to write data to another memory location and avoid the usual python reference pointer + # else one can overwrite data by accidient and change two variables at once without noticing self.p_old = self.p.copy() self.v_old = self.v.copy() diff --git a/Druckrohrleitung/Druckrohrleitung_test.ipynb b/Druckrohrleitung/Druckrohrleitung_test.ipynb deleted file mode 100644 index fca1668..0000000 --- a/Druckrohrleitung/Druckrohrleitung_test.ipynb +++ /dev/null @@ -1,237 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from Druckrohrleitung_class_file import Druckrohrleitung_class\n", - "import matplotlib.pyplot as plt\n", - "\n", - "#importing pressure conversion function\n", - "import sys\n", - "import os\n", - "current = os.path.dirname(os.path.realpath('Main_Programm.ipynb'))\n", - "parent = os.path.dirname(current)\n", - "sys.path.append(parent)\n", - "from functions.pressure_conversion import pressure_conversion" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib qt5\n", - "#define constants\n", - "\n", - "g = 9.81 # gravitational acceleration [m/s²]\n", - "rho = 1000 # density of water [kg/m³]\n", - "\n", - "L = 1000 # length of pipeline [m]\n", - "D = 1 # pipe diameter [m]\n", - "Q0 = 2 # initial flow in whole pipe [m³/s]\n", - "h_res = 20 # water level in upstream reservoir [m]\n", - "n = 10 # number of pipe segments in discretization\n", - "nt = 100 # number of time steps after initial conditions\n", - "f_D = 0.01 # Darcy friction factor\n", - "c = 400 # propagation velocity of the pressure wave [m/s]\n", - "h_pipe = 200 # hydraulic head without reservoir [m] \n", - "alpha = np.arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \n", - "\n", - "\n", - "# preparing the discretization and initial conditions\n", - "\n", - "dx = L/n # length of each pipe segment\n", - "dt = dx/c # timestep according to method of characterisitics\n", - "nn = n+1 # number of nodes\n", - "pl_vec = np.arange(0,nn*dx,dx) # pl = pipe-length. position of the nodes on the pipeline\n", - "t_vec = np.arange(0,nt*dt,dt) # time vector\n", - "h_vec = np.arange(0,h_pipe+h_pipe/n,h_pipe/n) # hydraulic head of pipeline at each node\n", - "\n", - "v_init = np.full(nn,Q0/(D**2/4*np.pi))\n", - "p_init = (rho*g*(h_res+h_vec)-v_init**2*rho/2)-(f_D*pl_vec/D*rho/2*v_init**2) # ref Wikipedia: Darcy Weisbach\n", - "\n", - "# storage vectors for old parameters\n", - "v_old = v_init.copy()\n", - "p_old = p_init.copy() \n", - "\n", - "# storage vectors for new parameters\n", - "v_new = np.empty_like(v_old)\n", - "p_new = np.empty_like(p_old)\n", - "\n", - "# storage vector for time evolution of parameters at node 0 (at reservoir)\n", - "p_0 = np.full_like(t_vec,p_init[0])\n", - "v_0 = np.full_like(t_vec,v_init[0])\n", - "\n", - "# storage vector for time evolution of parameters at node N+1 (at valve)\n", - "p_np1 = np.full_like(t_vec,p_init[-1])\n", - "v_np1 = np.full_like(t_vec,v_init[-1])\n", - "\n", - "for it in range(1,nt):\n", - "\n", - " # set boundary conditions\n", - " v_new[-1] = 0 # in front of the instantaneously closing valve, the velocity is 0\n", - " p_new[0] = p_init[0] # hydrostatic pressure from the reservoir\n", - "\n", - " # calculate the new parameters at first and last node\n", - " v_new[0] = v_old[1]+1/(rho*c)*(p_init[0]-p_old[1])+dt*g*np.sin(alpha)-f_D*dt/(2*D)*abs(v_old[1])*v_old[1]\n", - " p_new[-1] = p_old[-2]+rho*c*v_old[-2]-rho*c*f_D*dt/(2*D) *abs(v_old[-2])*v_old[-2]\n", - "\n", - " # calculate parameters at second to second-to-last nodes \n", - " #equation 2-30 plus 2-31 (and refactor for v_i^j+1) in block 2\n", - "\n", - " for i in range(1,nn-1):\n", - " v_new[i] = 0.5*(v_old[i-1]+v_old[i+1])+0.5/(rho*c)*(p_old[i-1]-p_old[i+1]) \\\n", - " +dt*g*np.sin(alpha)-f_D*dt/(4*D)*(abs(v_old[i-1])*v_old[i-1]+abs(v_old[i+1])*v_old[i+1])\n", - "\n", - " p_new[i] = 0.5*rho*c*(v_old[i-1]-v_old[i+1])+0.5*(p_old[i-1]+p_old[i+1]) \\\n", - " -rho*c*f_D*dt/(4*D)*(abs(v_old[i-1])*v_old[i-1]-abs(v_old[i+1])*v_old[i+1])\n", - " \n", - "\n", - " # prepare for next loop\n", - " # use .copy() to avoid that memory address is overwritten and hell breaks loose :D\n", - " #https://www.geeksforgeeks.org/array-copying-in-python/\n", - " p_old = p_new.copy()\n", - " v_old = v_new.copy()\n", - "\n", - " # store parameters of node 1 (at reservoir)\n", - " p_0[it] = p_new[0]\n", - " v_0[it] = v_new[0]\n", - " # store parameters of node N+1 (at reservoir)\n", - " p_np1[it] = p_new[-1]\n", - " v_np1[it] = v_new[-1]" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", - "\n", - "pipe.set_pressure_propagation_velocity(c)\n", - "pipe.set_number_of_timesteps(nt)\n", - "\n", - "pipe.set_initial_pressure(p_init)\n", - "pipe.set_initial_flow_velocity(v_init)\n", - "pipe.set_boundary_conditions_next_timestep(v_0[0],p_0[0],v_np1[0])\n", - "\n", - "# storage vector for time evolution of parameters at node 0 (at reservoir)\n", - "pipe.p_0 = np.full_like(t_vec,p_init[0])\n", - "pipe.v_0 = np.full_like(t_vec,v_init[0])\n", - "\n", - "# storage vector for time evolution of parameters at node N+1 (at valve)\n", - "pipe.p_np1 = np.full_like(t_vec,p_init[-1])\n", - "pipe.v_np1 = np.full_like(t_vec,v_init[-1])\n", - "\n", - "fig2,axs2 = plt.subplots(2,1)\n", - "axs2[0].set_title('Pressure distribution in pipeline')\n", - "axs2[1].set_title('Velocity distribution in pipeline')\n", - "axs2[0].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", - "axs2[0].set_ylabel(r'$p$ [mWS]')\n", - "axs2[1].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", - "axs2[1].set_ylabel(r'$p$ [mWS]')\n", - "lo_00, = axs2[0].plot(pl_vec,pressure_conversion(pipe.p_old,'Pa','mWS')[0],marker='.')\n", - "lo_01, = axs2[1].plot(pl_vec,pipe.v_old,marker='.')\n", - "axs2[0].set_ylim([-2*np.max(pressure_conversion(p_init,'Pa','mWS')[0]),2*np.max(pressure_conversion(p_init,'Pa','mWS')[0])])\n", - "axs2[1].set_ylim([-2*np.max(v_init),2*np.max(v_init)])\n", - "fig2.tight_layout()\n", - "\n", - "\n", - "for it in range(1,pipe.nt):\n", - " pipe.set_boundary_conditions_next_timestep(v_0[it],p_0[it],v_np1[it])\n", - " pipe.timestep_characteristic_method()\n", - " lo_00.set_ydata(pressure_conversion(pipe.p,'Pa','mWS')[0])\n", - " lo_01.set_ydata(pipe.v)\n", - "\n", - " # store parameters of node 0 (at reservoir)\n", - " pipe.p_0[it] = pipe.p[0]\n", - " pipe.v_0[it] = pipe.v[0]\n", - " # store parameters of node N+1 (at reservoir)\n", - " pipe.p_np1[it] = pipe.p[-1]\n", - " pipe.v_np1[it] = pipe.v[-1]\n", - " \n", - " fig2.suptitle(str(it))\n", - " fig2.canvas.draw()\n", - " fig2.tight_layout()\n", - " plt.pause(0.2)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "fig3,axs3 = plt.subplots(2,2)\n", - "axs3[0,0].plot(t_vec,pressure_conversion(pipe.p_0,'Pa','mWS')[0])\n", - "axs3[0,1].plot(t_vec,pipe.v_0)\n", - "axs3[1,0].plot(t_vec,pressure_conversion(pipe.p_np1,'Pa','mWS')[0])\n", - "axs3[1,1].plot(t_vec,pipe.v_np1)\n", - "axs3[0,0].set_title('Pressure Reservoir')\n", - "axs3[0,1].set_title('Velocity Reservoir')\n", - "axs3[1,0].set_title('Pressure Turbine')\n", - "axs3[1,1].set_title('Velocity Turbine')\n", - "axs3[0,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "axs3[0,0].set_ylabel(r'$p$ [mWS]')\n", - "axs3[0,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "axs3[0,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", - "axs3[1,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "axs3[1,0].set_ylabel(r'$p$ [mWS]')\n", - "axs3[1,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "axs3[1,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", - "fig3.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.29590621205048523\n" - ] - } - ], - "source": [ - "print(np.mean(v_0))" - ] - } - ], - "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 -} diff --git a/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb b/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb new file mode 100644 index 0000000..bc464e4 --- /dev/null +++ b/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb @@ -0,0 +1,202 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from Druckrohrleitung_class_file import Druckrohrleitung_class\n", + "import matplotlib.pyplot as plt\n", + "\n", + "#importing pressure conversion function\n", + "import sys\n", + "import os\n", + "current = os.path.dirname(os.path.realpath('Main_Programm.ipynb'))\n", + "parent = os.path.dirname(current)\n", + "sys.path.append(parent)\n", + "from functions.pressure_conversion import pressure_conversion" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib qt5\n", + "#define constants\n", + "\n", + "g = 9.81 # gravitational acceleration [m/s²]\n", + "rho = 1000 # density of water [kg/m³]\n", + "\n", + "L = 1000 # length of pipeline [m]\n", + "D = 1 # pipe diameter [m]\n", + "Q0 = 2 # initial flow in whole pipe [m³/s]\n", + "h_res = 20 # water level in upstream reservoir [m]\n", + "n = 10 # number of pipe segments in discretization\n", + "nt = 100 # number of time steps after initial conditions\n", + "f_D = 0.01 # Darcy friction factor\n", + "c = 400 # propagation velocity of the pressure wave [m/s]\n", + "h_pipe = 200 # hydraulic head without reservoir [m] \n", + "alpha = np.arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \n", + "\n", + "\n", + "# preparing the discretization and initial conditions\n", + "initial_influx = 2. # m³/s\n", + "initial_level = 10. # m\n", + "dx = L/n # length of each pipe segment\n", + "dt = dx/c # timestep according to method of characterisitics\n", + "nn = n+1 # number of nodes\n", + "pl_vec = np.arange(0,nn*dx,dx) # pl = pipe-length. position of the nodes on the pipeline\n", + "t_vec = np.arange(0,nt*dt,dt) # time vector\n", + "h_vec = np.arange(0,h_pipe+h_pipe/n,h_pipe/n) # hydraulic head of pipeline at each node\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", + "pipe.set_pressure_propagation_velocity(c)\n", + "pipe.set_number_of_timesteps(nt)\n", + "pipe.set_steady_state(initial_influx,initial_level,pl_vec,h_vec)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# initialization for timeloop\n", + "\n", + "# prepare the vectors in which the pressure and velocity distribution in the pipeline from the previous timestep are stored\n", + "v_old = pipe.get_current_velocity_distribution()\n", + "p_old = pipe.get_current_pressure_distribution()\n", + "\n", + "# prepare the vectors in which the temporal evolution of the boundary conditions are stored\n", + " # keep in mind, that the velocity at the turbine and the pressure at the reservoir are set manually and\n", + " # through the time evolution of the reservoir respectively \n", + " # the pressure at the turbine and the velocity at the reservoir are calculated from the method of characteristics\n", + "v_boundary_res = np.zeros_like(t_vec)\n", + "v_boundary_tur = np.zeros_like(t_vec)\n", + "p_boundary_res = np.zeros_like(t_vec)\n", + "p_boundary_tur = np.zeros_like(t_vec)\n", + "\n", + "# set the boundary conditions for the first timestep\n", + "v_boundary_res[0] = v_old[0]\n", + "v_boundary_tur[0] = v_old[-1] \n", + "p_boundary_res[0] = p_old[0]\n", + "p_boundary_tur[0] = p_old[-1]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "fig2,axs2 = plt.subplots(2,1)\n", + "axs2[0].set_title('Pressure distribution in pipeline')\n", + "axs2[0].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", + "axs2[0].set_ylabel(r'$p$ [mWS]')\n", + "lo_00, = axs2[0].plot(pl_vec,pressure_conversion(p_old,'Pa','mWS'),marker='.')\n", + "axs2[0].set_ylim([0.9*np.min(pressure_conversion(p_old,'Pa','mWS')),1.1*np.max(pressure_conversion(p_old,'Pa','mWS'))])\n", + "\n", + "axs2[1].set_title('Velocity distribution in pipeline')\n", + "axs2[1].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", + "axs2[1].set_ylabel(r'$p$ [mWS]')\n", + "lo_01, = axs2[1].plot(pl_vec,v_old,marker='.')\n", + "axs2[1].set_ylim([0.9*np.min(v_old),1.1*np.max(v_boundary_res)])\n", + "\n", + "fig2.tight_layout()\n", + "plt.pause(5)\n", + "\n", + "\n", + "for it in range(1,pipe.nt):\n", + " pipe.set_boundary_conditions_next_timestep(p_boundary_res[0],v_boundary_tur[0])\n", + " pipe.timestep_characteristic_method()\n", + " lo_00.set_ydata(pressure_conversion(pipe.get_current_pressure_distribution(),'Pa','mWS'))\n", + " lo_01.set_ydata(pipe.get_current_velocity_distribution())\n", + "\n", + " v_boundary_res[it] = pipe.get_current_velocity_distribution()[0]\n", + " v_boundary_tur[it] = pipe.get_current_velocity_distribution()[-1]\n", + " p_boundary_res[it] = pipe.get_current_pressure_distribution()[0]\n", + " p_boundary_tur[it] = pipe.get_current_pressure_distribution()[-1]\n", + "\n", + "\n", + " \n", + " fig2.suptitle(str(it))\n", + " fig2.canvas.draw()\n", + " fig2.tight_layout()\n", + " plt.pause(0.2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "fig3,axs3 = plt.subplots(2,2)\n", + "axs3[0,0].set_title('Pressure Reservoir')\n", + "axs3[0,0].plot(t_vec,pressure_conversion(p_boundary_res,'Pa','mWS'))\n", + "axs3[0,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs3[0,0].set_ylabel(r'$p$ [mWS]')\n", + "axs3[0,0].set_ylim([0.9*np.min(pressure_conversion(p_boundary_res,'Pa','mWS')),1.1*np.max(pressure_conversion(p_boundary_res,'Pa','mWS'))])\n", + "\n", + "axs3[0,1].set_title('Velocity Reservoir')\n", + "axs3[0,1].plot(t_vec,v_boundary_res)\n", + "axs3[0,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs3[0,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "axs3[0,1].set_ylim([0.9*np.min(v_boundary_res),1.1*np.max(v_boundary_res)])\n", + "\n", + "axs3[1,0].set_title('Pressure Turbine')\n", + "axs3[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,'Pa','mWS'))\n", + "axs3[1,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs3[1,0].set_ylabel(r'$p$ [mWS]')\n", + "axs3[1,0].set_ylim([0.9*np.min(pressure_conversion(p_boundary_tur,'Pa','mWS')),1.1*np.max(pressure_conversion(p_boundary_tur,'Pa','mWS'))])\n", + "\n", + "axs3[1,1].set_title('Velocity Turbine')\n", + "axs3[1,1].plot(t_vec,v_boundary_tur)\n", + "axs3[1,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs3[1,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "axs3[1,1].set_ylim([0.9*np.min(v_boundary_tur),1.1*np.max(v_boundary_tur)])\n", + "\n", + "fig3.tight_layout()\n", + "plt.show()" + ] + } + ], + "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 +} diff --git a/Regler/regler_test_optimierung.ipynb b/Regler/old/regler_test_optimierung.ipynb similarity index 100% rename from Regler/regler_test_optimierung.ipynb rename to Regler/old/regler_test_optimierung.ipynb diff --git a/Turbinen/Turbinen_class_file.py b/Turbinen/Turbinen_class_file.py index fa7e832..842b345 100644 --- a/Turbinen/Turbinen_class_file.py +++ b/Turbinen/Turbinen_class_file.py @@ -12,14 +12,16 @@ class Francis_Turbine: self.Q_n = Q_nenn self.p_n = p_nenn self.LA_n = 1. # 100% - h,_ = pressure_conversion(p_nenn,'Pa','MWs') + h = pressure_conversion(p_nenn,'Pa','MWs') self.A = Q_nenn/(np.sqrt(2*9.81*h)*0.98) def set_LA(self,LA): self.LA = LA + def set_pressure(self,pressure): + self.p = pressure - def get_Q(self,p): - self.Q = self.Q_n*(self.LA/self.LA_n)*np.sqrt(p/self.p_n) + def get_Q(self): + self.Q = self.Q_n*(self.LA/self.LA_n)*np.sqrt(self.p/self.p_n) return self.Q def set_closing_time(self,t_closing): diff --git a/Turbinen/Turbinen_test.ipynb b/Turbinen/Turbinen_test.ipynb index 23d5dd8..7cfe0c3 100644 --- a/Turbinen/Turbinen_test.ipynb +++ b/Turbinen/Turbinen_test.ipynb @@ -25,20 +25,11 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.018834355072879172\n" - ] - } - ], + "outputs": [], "source": [ "Q_nenn = 0.85\n", - "p_nenn,_ = pressure_conversion(10.6,'bar','Pa')\n", - "Untertweng1 = Francis_Turbine(Q_nenn,p_nenn)\n", - "print(Untertweng1.A)" + "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", + "Untertweng1 = Francis_Turbine(Q_nenn,p_nenn)" ] }, { @@ -56,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -65,14 +56,14 @@ "Text(0.5, 0, 'Q [m³/s]')" ] }, - "execution_count": 4, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a76ad86e29fd4594a88621371ce94083", + "model_id": "7650cd2a1f9a4b87b98e70add29f11a7", "version_major": 2, "version_minor": 0 }, @@ -99,7 +90,12 @@ "Q_mat = np.empty([n_LA,n_p])\n", "\n", "pp,ll = np.meshgrid(ps,LAs)\n", - "Q_mat = Untertweng1.get_Q(pp,ll)\n", + "\n", + "for i in range(n_p):\n", + " for j in range(n_LA):\n", + " Untertweng1.set_pressure(pp[i,j])\n", + " Untertweng1.set_LA(ll[i,j])\n", + " Q_mat[i,j] = Untertweng1.get_Q()\n", "\n", "fig1 = plt.figure()\n", "ax1 = plt.axes(projection='3d')\n", @@ -112,79 +108,42 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 27, "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2b95e8650af64ab7a401d9624aef4b85", - "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": [ - "d_LA_test = 1/(n_LA-1)\n", - "\n", - "LA_test = np.arange(0,n_LA,1)*d_LA_test\n", - "\n", - "fig = plt.figure()\n", - "plt.xlabel('Druck [Pa]')\n", - "plt.ylabel('Q [m³/s]')\n", - "\n", - "for i in range(n_LA):\n", - " LA_index = int(np.argwhere(LAs == LA_test[i]))\n", - " plt.plot(ps,Q_mat[LA_index,:])" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\BRANT\\AppData\\Local\\Temp\\9\\ipykernel_7508\\1599598770.py:5: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).\n", + " fig = plt.figure()\n" + ] + }, { "data": { "text/plain": [ - "Text(0.5, 1.0, 'P = 1144800.0 [Pa]')" + "(0.0, 1.275)" ] }, - "execution_count": 11, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bce1ff4c4e1946ff93e954cd79af4bfe", + "model_id": "52152d0b96c74a4ebfb18041a22d8d0e", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -197,7 +156,61 @@ } ], "source": [ - "p_test,_ = pressure_conversion(11.4,'bar','Pa')\n", + "LA_test = 0.1\n", + "LA_index = int(np.argmin(abs(LAs-LA_test)))\n", + "LA_test2 = LAs[LA_index]\n", + "\n", + "fig = plt.figure()\n", + "plt.plot(ps,Q_mat[LA_index,:])\n", + "plt.xlabel('p [PA]')\n", + "plt.ylabel('Q [m³/s]')\n", + "plt.title('LA = '+ str(100*LA_test2) + ' [%]')\n", + "plt.ylim([0,1.5*Q_nenn])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 1.275)" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bf6b0fe84d264693813f6e991600ece1", + "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": [ + "p_test = pressure_conversion(20.,'bar','Pa')\n", "p_index = int(np.argmin(abs(ps-p_test)))\n", "p_test2 = ps[p_index]\n", "\n", @@ -205,7 +218,25 @@ "plt.plot(LAs,Q_mat[:,p_index])\n", "plt.xlabel('LA [-]')\n", "plt.ylabel('Q [m³/s]')\n", - "plt.title('P = '+ str(p_test2) + ' [Pa]')" + "plt.title('P = '+ str(p_test2) + ' [Pa]')\n", + "plt.ylim([0,1.5*Q_nenn])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "53000.0\n" + ] + } + ], + "source": [ + "print(pp[10,5])" ] } ], diff --git a/Untertweng.ipynb b/Untertweng.ipynb index cd4de2e..b2baf53 100644 --- a/Untertweng.ipynb +++ b/Untertweng.ipynb @@ -25,7 +25,7 @@ "\n", "#Turbine\n", "Q_nenn = 0.85\n", - "p_nenn,_ = pressure_conversion(10.6,'bar','Pa')\n", + "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", "\n", "# physics\n", "g = 9.81 # gravitational acceleration [m/s²]\n", @@ -104,12 +104,12 @@ "# create objects\n", "\n", "V = Ausgleichsbecken_class(area_base,area_outflux,critical_level_low,critical_level_high,simulation_timestep)\n", - "V.set_steady_state(initial_influx,initial_level,initial_pressure_unit,conversion_pressure_unit)\n", + "V.set_steady_state(initial_influx,initial_level,conversion_pressure_unit)\n", "\n", "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", "pipe.set_pressure_propagation_velocity(c)\n", "pipe.set_number_of_timesteps(nt)\n", - "pipe.set_steady_state(initial_influx,V.level,pl_vec,h_vec,initial_pressure_unit,conversion_pressure_unit)\n", + "pipe.set_steady_state(initial_influx,V.level,pl_vec,h_vec)\n", "\n", "\n", "T1 = Francis_Turbine(Q_nenn,p_nenn)\n", @@ -137,14 +137,14 @@ " # keep in mind, that the velocity at the turbine and the pressure at the reservoir are set manually and\n", " # through the time evolution of the reservoir respectively \n", " # the pressure at the turbine and the velocity at the reservoir are calculated from the method of characteristics\n", - "v_boundary_res = np.empty_like(t_vec)\n", - "v_boundary_tur = np.empty_like(t_vec)\n", - "p_boundary_res = np.empty_like(t_vec)\n", - "p_boundary_tur = np.empty_like(t_vec)\n", + "v_boundary_res = np.zeros_like(t_vec)\n", + "v_boundary_tur = np.zeros_like(t_vec)\n", + "p_boundary_res = np.zeros_like(t_vec)\n", + "p_boundary_tur = np.zeros_like(t_vec)\n", "\n", "# prepare the vectors that store the temporal evolution of the level in the reservoir\n", "level_vec = np.full(nt+1,V.level) # level at the end of each pipeline timestep\n", - "level_vec_2 = np.empty([nt_eRK4]) # level throughout each reservoir timestep-used for plotting and overwritten afterwards\n", + "level_vec_2 = np.zeros([nt_eRK4]) # level throughout each reservoir timestep-used for plotting and overwritten afterwards\n", "\n", "# set the boundary conditions for the first timestep\n", "v_boundary_res[0] = v_old[0]\n", @@ -176,7 +176,7 @@ "axs1[0].set_ylabel(r'$p$ ['+conversion_pressure_unit+']')\n", "axs1[1].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", "axs1[1].set_ylabel(r'$v$ [$\\mathrm{m} / \\mathrm{s}$]')\n", - "lo_00, = axs1[0].plot(pl_vec,pressure_conversion(pipe.p_old,initial_pressure_unit, conversion_pressure_unit)[0],marker='.')\n", + "lo_00, = axs1[0].plot(pl_vec,pressure_conversion(pipe.p_old,initial_pressure_unit, conversion_pressure_unit),marker='.')\n", "lo_01, = axs1[1].plot(pl_vec,pipe.v_old,marker='.')\n", "axs1[0].autoscale()\n", "axs1[1].autoscale()\n", @@ -193,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -208,7 +208,7 @@ " for it_res in range(nt_eRK4):\n", " V.e_RK_4() # call e-RK4 to update outflux\n", " V.level = V.update_level(V.timestep) # \n", - " V.set_volume() # update volume in reservoir\n", + " V.update_volume() # update volume in reservoir\n", " level_vec_2[it_res] = V.level # save for plotting\n", " if (V.level < critical_level_low) or (V.level > critical_level_high): # make sure to never exceed critical levels\n", " i_max = it_pipe # for plotting only calculated values\n", @@ -217,15 +217,14 @@ "\n", " # set boundary conditions for the next timestep of the characteristic method\n", " p_boundary_res[it_pipe] = rho*g*V.level-V.outflux_vel**2*rho/2\n", - " v_boundary_res[it_pipe] = v_old[1]+1/(rho*c)*(p_boundary_res[it_pipe]-p_old[1])-f_D*dt/(2*D)*abs(v_old[1])*v_old[1] \\\n", - " +dt*g*np.sin(alpha)\n", "\n", " T1.change_LA(LA_soll_vec[it_pipe],dt)\n", " v_boundary_tur[it_pipe] = 1/A_pipe*T1.get_Q(p_old[-1])\n", "\n", " # the the boundary conditions in the pipe.object and thereby calculate boundary pressure at turbine\n", - " pipe.set_boundary_conditions_next_timestep(v_boundary_res[it_pipe],p_boundary_res[it_pipe],v_boundary_tur[it_pipe])\n", + " pipe.set_boundary_conditions_next_timestep(p_boundary_res[it_pipe],v_boundary_tur[it_pipe])\n", " p_boundary_tur[it_pipe] = pipe.p_boundary_tur\n", + " v_boundary_res[it_pipe] = pipe.v_boundary_res\n", "\n", " # perform the next timestep via the characteristic method\n", " pipe.timestep_characteristic_method()\n", @@ -236,7 +235,7 @@ " lo_01.remove()\n", " # lo_02.remove()\n", " # plot new pressure and velocity distribution in the pipeline\n", - " lo_00, = axs1[0].plot(pl_vec,pressure_conversion(pipe.p_old,initial_pressure_unit, conversion_pressure_unit)[0],marker='.',c='blue')\n", + " lo_00, = axs1[0].plot(pl_vec,pressure_conversion(pipe.p_old,initial_pressure_unit, conversion_pressure_unit),marker='.',c='blue')\n", " lo_01, = axs1[1].plot(pl_vec,pipe.v_old,marker='.',c='blue')\n", " # lo_02, = axs1[2].plot(level_vec_2,c='blue')\n", " fig1.suptitle(str(round(t_vec[it_pipe],2))+ ' s / '+str(round(t_vec[-1],2)) + ' s' )\n", @@ -255,16 +254,17 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# plot time evolution of boundary pressure and velocity as well as the reservoir level\n", "\n", "fig2,axs2 = plt.subplots(3,2)\n", - "axs2[0,0].plot(t_vec,pressure_conversion(p_boundary_res,initial_pressure_unit, conversion_pressure_unit)[0])\n", + "axs2[0,0].plot(t_vec,pressure_conversion(p_boundary_res,initial_pressure_unit, conversion_pressure_unit))\n", "axs2[0,1].plot(t_vec,v_boundary_res)\n", - "axs2[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,initial_pressure_unit, conversion_pressure_unit)[0])\n", + "axs2[0,1].set_ylim(-2*Q_nenn,+2*Q_nenn)\n", + "axs2[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,initial_pressure_unit, conversion_pressure_unit))\n", "axs2[1,1].plot(t_vec,v_boundary_tur)\n", "axs2[2,0].plot(t_vec,level_vec)\n", "axs2[0,0].set_title('Pressure reservoir')\n", @@ -290,7 +290,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('DT_Slot_3')", + "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", "language": "python", "name": "python3" }, @@ -309,7 +309,7 @@ "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" + "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" } } }, From d1c15090dc618851432a908b0c8746d6c17f4a0d Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Wed, 27 Jul 2022 11:40:58 +0200 Subject: [PATCH 03/11] code cleanup: consistenly use getter and setter methods commenting etc --- .../Ausgleichsbecken_class_file.py | 33 ++- .../Ausgleichsbecken_test_steady_state.ipynb | 38 +-- .../Druckrohrleitung_class_file.py | 21 +- .../Druckrohrleitung_test_steady_state.ipynb | 236 +++++++++------ Kraftwerk/Kraftwerk_class_file.py | 19 ++ Kraftwerk/Kraftwerk_class_test.ipynb | 105 +++++++ ...gler_test.ipynb => Pegelregler_test.ipynb} | 275 ++++++++---------- Regler/Regler_class_file.py | 117 +++++--- Turbinen/Turbinen_class_file.py | 121 ++++++-- ...st.ipynb => Turbinen_test_Kennlinie.ipynb} | 78 +++-- Turbinen/messy.ipynb | 90 ++++++ Untertweng.ipynb | 170 +++++------ Untertweng_mit_Pegelregler.ipynb | 237 ++++++++------- 13 files changed, 956 insertions(+), 584 deletions(-) create mode 100644 Kraftwerk/Kraftwerk_class_file.py create mode 100644 Kraftwerk/Kraftwerk_class_test.ipynb rename Regler/{regler_test.ipynb => Pegelregler_test.ipynb} (59%) rename Turbinen/{Turbinen_test.ipynb => Turbinen_test_Kennlinie.ipynb} (99%) create mode 100644 Turbinen/messy.ipynb diff --git a/Ausgleichsbecken/Ausgleichsbecken_class_file.py b/Ausgleichsbecken/Ausgleichsbecken_class_file.py index e8242d6..937e082 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken/Ausgleichsbecken_class_file.py @@ -44,8 +44,8 @@ class Ausgleichsbecken_class: density_unit_print = 'kg/m³' flux_unit_print = 'm³/s' level_unit_print = 'm' - time_unit_print = 's' pressure_unit_print = '--' # will be set by .set_pressure() method + time_unit_print = 's' velocity_unit_print = 'm/s' volume_unit_print = 'm³' @@ -102,8 +102,7 @@ class Ausgleichsbecken_class: # set the steady state (ss) condition in which the net flux is zero # set pressure acting on the outflux area so that the level stays constant ss_outflux = ss_influx - ss_outflux_vel = ss_outflux/self.area_outflux - ss_pressure = self.density*self.g*ss_level-ss_outflux_vel**2*self.density/2 + ss_pressure = self.density*self.g*ss_level-(ss_outflux/self.area_outflux)**2*self.density/2 self.set_influx(ss_influx) self.set_initial_level(ss_level) @@ -169,6 +168,9 @@ class Ausgleichsbecken_class: def update_level(self,timestep): # update level based on net flux and timestep by calculating the volume change in # the timestep and the converting the new volume to a level by assuming a cuboid reservoir + + # cannot set new level directly in this method, because it gets called to calcuate during the Runge Kutta + # to calculate a ficticious level at half the timestep net_flux = self.influx-self.outflux delta_V = net_flux*timestep new_level = (self.volume+delta_V)/self.area @@ -178,31 +180,32 @@ class Ausgleichsbecken_class: # sets volume in reservoir based on self.level return self.level*self.area + def update_pressure(self): + p_new = self.density*self.g*self.level-(self.outflux/self.area_outflux)**2*self.density/2 + return p_new def timestep_reservoir_evolution(self): # update outflux and outflux velocity based on current pipeline pressure and waterlevel in reservoir - yn = self.outflux/self.area_outflux # outflux velocity - h = self.level dt = self.timestep - p = self.pressure - # assume constant pipeline pressure during timestep - # e_RK_4 timestep is way smalle than timestep of characteristic method, so this should be a valid approx. - # (furthermore I have no idea how to approximate p_hs otherwise :/ ) - p_hs = self.pressure - A_a = self.area_outflux - A = self.area - h_hs = self.update_level(dt/2) rho = self.density g = self.g + A = self.area + A_a = self.area_outflux + yn = self.outflux/A_a # outflux velocity + h = self.level + h_hs = self.update_level(dt/2) + p = self.pressure + p_hs = self.pressure + rho*g*(h_hs-h) # explicit 4 step Runge Kutta Y1 = yn - Y2 = yn + dt/2*FODE_function(Y1,h,A,A_a,self.pressure,rho,g) + Y2 = yn + dt/2*FODE_function(Y1,h,A,A_a,p,rho,g) Y3 = yn + dt/2*FODE_function(Y2,h_hs,A,A_a,p_hs,rho,g) Y4 = yn + dt*FODE_function(Y3,h_hs,A,A_a,p_hs,rho,g) ynp1 = yn + dt/6*(FODE_function(Y1,h,A,A_a,p,rho,g)+2*FODE_function(Y2,h_hs,A,A_a,p_hs,rho,g)+ \ 2*FODE_function(Y3,h_hs,A,A_a,p_hs,rho,g)+ FODE_function(Y4,h,A,A_a,p,rho,g)) - self.outflux = ynp1*self.area_outflux + self.outflux = ynp1*A_a self.level = self.update_level(dt) self.volume = self.update_volume() + self.pressure = self.update_pressure() diff --git a/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb b/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb index 8838088..1b82115 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb +++ b/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb @@ -28,9 +28,9 @@ "# define constants\n", "initial_level = 10. # m\n", "initial_influx = 5. # m³/s\n", - "initial_outflux = 1. # m³/s\n", - "initial_pipeline_pressure = 10.\n", - "initial_pressure_unit = 'mWS'\n", + "# initial_outflux = 1. # m³/s\n", + "# initial_pipeline_pressure = 10.\n", + "# initial_pressure_unit = 'mWS'\n", "conversion_pressure_unit = 'mWS'\n", "\n", "area_base = 1. # m²\n", @@ -41,12 +41,12 @@ "\n", "# for while loop\n", "total_min_level = 0.01 # m\n", - "total_max_time = 1000 # s" + "total_max_time = 1000 # s" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,6 @@ "i_max = -1\n", "\n", "for i in range(np.size(time_vec)-1):\n", - " # update to include p_halfstep\n", " V.set_pressure(pressure_vec[i])\n", " V.timestep_reservoir_evolution()\n", " outflux_vec[i+1] = V.get_current_outflux()\n", @@ -85,12 +84,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "\n", - "fig1, (ax1, ax2, ax3, ax4) = plt.subplots(4, 1)\n", + "fig1, (ax1, ax2, ax3) = plt.subplots(3, 1)\n", "fig1.set_figheight(10)\n", "fig1.suptitle('Ausgleichsbecken')\n", "\n", @@ -109,29 +108,6 @@ "ax3.set_xlabel(r'$t$ ['+V.time_unit+']')\n", "ax3.legend()\n", "\n", - "# plt.subplots_adjust(left=0.2, bottom=0.2)\n", - "ax4.set_axis_off()\n", - "cell_text = np.array([[level_vec[0], V.level_unit], \\\n", - " [initial_influx, V.flux_unit], \\\n", - " [outflux_vec[0], V.flux_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", - " '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() " ] diff --git a/Druckrohrleitung/Druckrohrleitung_class_file.py b/Druckrohrleitung/Druckrohrleitung_class_file.py index df9a3c1..71d553b 100644 --- a/Druckrohrleitung/Druckrohrleitung_class_file.py +++ b/Druckrohrleitung/Druckrohrleitung_class_file.py @@ -33,6 +33,8 @@ class Druckrohrleitung_class: self.density = rho # density of the liquid in the pipeline self.g = g # gravitational acceleration + self.A = (diameter/2)**2*np.pi + self.dx = total_length/number_segments # length of each segment self.l_vec = np.arange(0,(number_segments+1),1)*self.dx # vector giving the distance from each node to the start of the pipeline @@ -98,23 +100,22 @@ class Druckrohrleitung_class: p_old_res = self.p_old[1] # @ second node (the one after the reservoir) v_old_res = self.v_old[1] # @ second node (the one after the reservoir) # set the boundary conditions derived from reservoir and turbine - self.v_boundary_tur = v_turbine # at new timestep - self.p_boundary_res = p_reservoir # at new timestep + v_boundary_tur = v_turbine # at new timestep + p_boundary_res = p_reservoir # at new timestep # calculate the missing boundary conditions - self.v_boundary_res = v_old_res+1/(rho*c)*(p_reservoir-p_old_res)+dt*g*np.sin(alpha)-f_D*dt/(2*D)*abs(v_old_res)*v_old_res - self.p_boundary_tur = p_old_tur-rho*c*(v_turbine-v_old_tur)+rho*c*dt*g*np.sin(alpha)-f_D*rho*c*dt/(2*D)*abs(v_old_tur)*v_old_tur + v_boundary_res = v_old_res+1/(rho*c)*(p_boundary_res-p_old_res)+dt*g*np.sin(alpha)-f_D*dt/(2*D)*abs(v_old_res)*v_old_res + p_boundary_tur = p_old_tur-rho*c*(v_boundary_tur-v_old_tur)+rho*c*dt*g*np.sin(alpha)-f_D*rho*c*dt/(2*D)*abs(v_old_tur)*v_old_tur # write boundary conditions to the velocity/pressure vectors of the next timestep - self.v[0] = self.v_boundary_res.copy() - self.v[-1] = self.v_boundary_tur.copy() - self.p[0] = self.p_boundary_res.copy() - self.p[-1] = self.p_boundary_tur.copy() - + self.v[0] = v_boundary_res + self.v[-1] = v_boundary_tur + self.p[0] = p_boundary_res + self.p[-1] = p_boundary_tur def set_steady_state(self,ss_flux,ss_level_reservoir,pl_vec,h_vec): # set the pressure and velocity distributions, that allow a constant flow of water from the (steady-state) reservoir to the (steady-state) turbine # the flow velocity is given by the constant flow through the pipe - ss_v0 = np.full(self.n_seg+1,ss_flux/(self.dia**2/4*np.pi)) + ss_v0 = np.full(self.n_seg+1,ss_flux/self.A) # the static pressure is given by the hydrostatic pressure, corrected for friction losses and dynamic pressure ss_pressure = (self.density*self.g*(ss_level_reservoir+h_vec)-ss_v0**2*self.density/2)-(self.f_D*pl_vec/self.dia*self.density/2*ss_v0**2) diff --git a/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb b/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb index bc464e4..e92c8b6 100644 --- a/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb +++ b/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -16,64 +16,98 @@ "current = os.path.dirname(os.path.realpath('Main_Programm.ipynb'))\n", "parent = os.path.dirname(current)\n", "sys.path.append(parent)\n", - "from functions.pressure_conversion import pressure_conversion" + "from functions.pressure_conversion import pressure_conversion\n", + "from Ausgleichsbecken.Ausgleichsbecken_class_file import Ausgleichsbecken_class" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib qt5\n", - "#define constants\n", + "#define constants pipe\n", "\n", - "g = 9.81 # gravitational acceleration [m/s²]\n", - "rho = 1000 # density of water [kg/m³]\n", + "g = 9.81 # gravitational acceleration [m/s²]\n", + "rho = 1000. # density of water [kg/m³]\n", "\n", - "L = 1000 # length of pipeline [m]\n", - "D = 1 # pipe diameter [m]\n", - "Q0 = 2 # initial flow in whole pipe [m³/s]\n", - "h_res = 20 # water level in upstream reservoir [m]\n", - "n = 10 # number of pipe segments in discretization\n", - "nt = 100 # number of time steps after initial conditions\n", - "f_D = 0.01 # Darcy friction factor\n", - "c = 400 # propagation velocity of the pressure wave [m/s]\n", - "h_pipe = 200 # hydraulic head without reservoir [m] \n", - "alpha = np.arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \n", + "L = 1000. # length of pipeline [m]\n", + "D = 0.9 # pipe diameter [m]\n", + "h_res = 10. # water level in upstream reservoir [m]\n", + "n = 50 # number of pipe segments in discretization\n", + "nt = 5000 # number of time steps after initial conditions\n", + "f_D = 0.01 # Darcy friction factor\n", + "c = 400. # propagation velocity of the pressure wave [m/s]\n", + "h_pipe = 105. # hydraulic head without reservoir [m] \n", + "alpha = np.arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \n", "\n", "\n", "# preparing the discretization and initial conditions\n", - "initial_influx = 2. # m³/s\n", - "initial_level = 10. # m\n", + "initial_flux = 0.8 # m³/s\n", + "initial_level = h_res # m\n", "dx = L/n # length of each pipe segment\n", "dt = dx/c # timestep according to method of characterisitics\n", "nn = n+1 # number of nodes\n", "pl_vec = np.arange(0,nn*dx,dx) # pl = pipe-length. position of the nodes on the pipeline\n", "t_vec = np.arange(0,nt*dt,dt) # time vector\n", - "h_vec = np.arange(0,h_pipe+h_pipe/n,h_pipe/n) # hydraulic head of pipeline at each node\n" + "h_vec = np.arange(0,h_pipe+h_pipe/n,h_pipe/n) # hydraulic head of pipeline at each node\n", + "\n", + "\n", + "# define constants reservoir\n", + "conversion_pressure_unit = 'mWS'\n", + "\n", + "area_base = 75. # m²\n", + "area_pipe = (D/2)**2*np.pi # m²\n", + "critical_level_low = 0. # m\n", + "critical_level_high = 100. # m\n", + "\n", + "# make sure e-RK4 method of reservoir has a small enough timestep to avoid runaway numerical error\n", + "nt_eRK4 = 1 # number of simulation steps of reservoir in between timesteps of pipeline \n", + "simulation_timestep = dt/nt_eRK4" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ + "V = Ausgleichsbecken_class(area_base, area_pipe, critical_level_low, critical_level_high,simulation_timestep)\n", + "V.set_steady_state(initial_flux,initial_level,conversion_pressure_unit)\n", + "\n", "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", "pipe.set_pressure_propagation_velocity(c)\n", "pipe.set_number_of_timesteps(nt)\n", - "pipe.set_steady_state(initial_influx,initial_level,pl_vec,h_vec)" + "pipe.set_steady_state(initial_flux,initial_level,pl_vec,h_vec)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(V.get_current_influx())\n", + "print(V.get_current_outflux())\n", + "print(V.get_current_level())\n", + "print(V.get_current_pressure())\n", + "print(pipe.get_current_pressure_distribution()[0])\n", + "print(pipe.get_current_velocity_distribution()*area_pipe)\n", + "print(pipe.get_current_velocity_distribution())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# initialization for timeloop\n", "\n", + "level_vec = np.zeros_like(t_vec)\n", + "level_vec[0] = V.get_current_level()\n", + "\n", "# prepare the vectors in which the pressure and velocity distribution in the pipeline from the previous timestep are stored\n", "v_old = pipe.get_current_velocity_distribution()\n", "p_old = pipe.get_current_pressure_distribution()\n", @@ -94,80 +128,110 @@ "p_boundary_tur[0] = p_old[-1]\n" ] }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "fig2,axs2 = plt.subplots(2,1)\n", - "axs2[0].set_title('Pressure distribution in pipeline')\n", - "axs2[0].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", - "axs2[0].set_ylabel(r'$p$ [mWS]')\n", - "lo_00, = axs2[0].plot(pl_vec,pressure_conversion(p_old,'Pa','mWS'),marker='.')\n", - "axs2[0].set_ylim([0.9*np.min(pressure_conversion(p_old,'Pa','mWS')),1.1*np.max(pressure_conversion(p_old,'Pa','mWS'))])\n", - "\n", - "axs2[1].set_title('Velocity distribution in pipeline')\n", - "axs2[1].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", - "axs2[1].set_ylabel(r'$p$ [mWS]')\n", - "lo_01, = axs2[1].plot(pl_vec,v_old,marker='.')\n", - "axs2[1].set_ylim([0.9*np.min(v_old),1.1*np.max(v_boundary_res)])\n", - "\n", - "fig2.tight_layout()\n", - "plt.pause(5)\n", - "\n", - "\n", - "for it in range(1,pipe.nt):\n", - " pipe.set_boundary_conditions_next_timestep(p_boundary_res[0],v_boundary_tur[0])\n", - " pipe.timestep_characteristic_method()\n", - " lo_00.set_ydata(pressure_conversion(pipe.get_current_pressure_distribution(),'Pa','mWS'))\n", - " lo_01.set_ydata(pipe.get_current_velocity_distribution())\n", - "\n", - " v_boundary_res[it] = pipe.get_current_velocity_distribution()[0]\n", - " v_boundary_tur[it] = pipe.get_current_velocity_distribution()[-1]\n", - " p_boundary_res[it] = pipe.get_current_pressure_distribution()[0]\n", - " p_boundary_tur[it] = pipe.get_current_pressure_distribution()[-1]\n", - "\n", - "\n", - " \n", - " fig2.suptitle(str(it))\n", - " fig2.canvas.draw()\n", - " fig2.tight_layout()\n", - " plt.pause(0.2)\n" - ] - }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "fig3,axs3 = plt.subplots(2,2)\n", - "axs3[0,0].set_title('Pressure Reservoir')\n", - "axs3[0,0].plot(t_vec,pressure_conversion(p_boundary_res,'Pa','mWS'))\n", - "axs3[0,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "axs3[0,0].set_ylabel(r'$p$ [mWS]')\n", - "axs3[0,0].set_ylim([0.9*np.min(pressure_conversion(p_boundary_res,'Pa','mWS')),1.1*np.max(pressure_conversion(p_boundary_res,'Pa','mWS'))])\n", + "fig1,axs1 = plt.subplots(2,1)\n", + "axs1[0].set_title('Pressure distribution in pipeline')\n", + "axs1[0].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", + "axs1[0].set_ylabel(r'$p$ [mWS]')\n", + "lo_00, = axs1[0].plot(pl_vec,pressure_conversion(p_old,'Pa',conversion_pressure_unit),marker='.')\n", + "axs1[0].set_ylim([0.9*np.min(pressure_conversion(p_old,'Pa',conversion_pressure_unit)),1.1*np.max(pressure_conversion(p_old,'Pa',conversion_pressure_unit))])\n", "\n", - "axs3[0,1].set_title('Velocity Reservoir')\n", - "axs3[0,1].plot(t_vec,v_boundary_res)\n", - "axs3[0,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "axs3[0,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", - "axs3[0,1].set_ylim([0.9*np.min(v_boundary_res),1.1*np.max(v_boundary_res)])\n", + "axs1[1].set_title('Velocity distribution in pipeline')\n", + "axs1[1].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", + "axs1[1].set_ylabel(r'$v$ [m/s]')\n", + "lo_01, = axs1[1].plot(pl_vec,v_old,marker='.')\n", + "# axs1[1].set_ylim([0.9*np.min(v_old),1.1*np.max(v_boundary_res)])\n", "\n", - "axs3[1,0].set_title('Pressure Turbine')\n", - "axs3[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,'Pa','mWS'))\n", - "axs3[1,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "axs3[1,0].set_ylabel(r'$p$ [mWS]')\n", - "axs3[1,0].set_ylim([0.9*np.min(pressure_conversion(p_boundary_tur,'Pa','mWS')),1.1*np.max(pressure_conversion(p_boundary_tur,'Pa','mWS'))])\n", + "fig1.tight_layout()\n", + "plt.pause(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ "\n", - "axs3[1,1].set_title('Velocity Turbine')\n", - "axs3[1,1].plot(t_vec,v_boundary_tur)\n", - "axs3[1,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "axs3[1,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", - "axs3[1,1].set_ylim([0.9*np.min(v_boundary_tur),1.1*np.max(v_boundary_tur)])\n", + "for it_pipe in range(1,nt):\n", + "# for each pipeline timestep, execute nt_eRK4 timesteps of the reservoir code\n", + " # set initial conditions for the reservoir time evolution calculted with e-RK4\n", + " V.set_pressure = p_old[0]\n", + " V.set_outflux = v_old[0]*area_pipe\n", + " # calculate the time evolution of the reservoir level within each pipeline timestep to avoid runaway numerical error\n", + " for it_res in range(nt_eRK4):\n", + " V.timestep_reservoir_evolution() \n", + " level_vec[it_pipe] = V.get_current_level() \n", "\n", - "fig3.tight_layout()\n", + " \n", + " # set boundary conditions for the next timestep of the characteristic method\n", + " p_boundary_res[it_pipe] = V.get_current_pressure()\n", + " v_boundary_tur[it_pipe] = initial_flux/area_pipe\n", + "\n", + " # the the boundary conditions in the pipe.object and thereby calculate boundary pressure at turbine\n", + " pipe.set_boundary_conditions_next_timestep(p_boundary_res[it_pipe],v_boundary_tur[it_pipe])\n", + " p_boundary_tur[it_pipe] = pipe.get_current_pressure_distribution()[-1]\n", + " v_boundary_res[it_pipe] = pipe.get_current_velocity_distribution()[0]\n", + "\n", + " # perform the next timestep via the characteristic method\n", + " pipe.timestep_characteristic_method()\n", + "\n", + " # prepare for next loop\n", + " p_old = pipe.get_current_pressure_distribution()\n", + " v_old = pipe.get_current_velocity_distribution()\n", + "\n", + " # plot some stuff\n", + " # remove line-objects to autoscale axes (there is definetly a better way, but this works ¯\\_(ツ)_/¯ )\n", + " lo_00.remove()\n", + " lo_01.remove()\n", + " # lo_02.remove()\n", + " # plot new pressure and velocity distribution in the pipeline\n", + " lo_00, = axs1[0].plot(pl_vec,pressure_conversion(p_old,'Pa', conversion_pressure_unit),marker='.',c='blue')\n", + " lo_01, = axs1[1].plot(pl_vec,v_old,marker='.',c='blue')\n", + " \n", + " fig1.suptitle(str(round(t_vec[it_pipe],2)) + '/' + str(t_vec[-1]))\n", + " fig1.canvas.draw()\n", + " fig1.tight_layout()\n", + " plt.pause(0.00001)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig2,axs2 = plt.subplots(2,2)\n", + "axs2[0,0].set_title('Pressure Reservoir')\n", + "axs2[0,0].plot(t_vec,pressure_conversion(p_boundary_res,'Pa',conversion_pressure_unit))\n", + "axs2[0,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[0,0].set_ylabel(r'$p$ [mWS]')\n", + "axs2[0,0].set_ylim([0.9*np.min(pressure_conversion(p_boundary_res,'Pa',conversion_pressure_unit)),1.1*np.max(pressure_conversion(p_boundary_res,'Pa',conversion_pressure_unit))])\n", + "\n", + "axs2[0,1].set_title('Velocity Reservoir')\n", + "axs2[0,1].plot(t_vec,v_boundary_res)\n", + "axs2[0,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[0,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "axs2[0,1].set_ylim([0.9*np.min(v_boundary_res),1.1*np.max(v_boundary_res)])\n", + "\n", + "axs2[1,0].set_title('Pressure Turbine')\n", + "axs2[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,'Pa',conversion_pressure_unit))\n", + "axs2[1,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[1,0].set_ylabel(r'$p$ [mWS]')\n", + "axs2[1,0].set_ylim([0.9*np.min(pressure_conversion(p_boundary_tur,'Pa',conversion_pressure_unit)),1.1*np.max(pressure_conversion(p_boundary_tur,'Pa',conversion_pressure_unit))])\n", + "\n", + "axs2[1,1].set_title('Velocity Turbine')\n", + "axs2[1,1].plot(t_vec,v_boundary_tur)\n", + "axs2[1,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[1,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "axs2[1,1].set_ylim([0.9*np.min(v_boundary_tur),1.1*np.max(v_boundary_tur)])\n", + "\n", + "fig2.tight_layout()\n", "plt.show()" ] } diff --git a/Kraftwerk/Kraftwerk_class_file.py b/Kraftwerk/Kraftwerk_class_file.py new file mode 100644 index 0000000..efcabd4 --- /dev/null +++ b/Kraftwerk/Kraftwerk_class_file.py @@ -0,0 +1,19 @@ +#importing Druckrohrleitung +import sys +import os +current = os.path.dirname(os.path.realpath('Main_Programm.ipynb')) +parent = os.path.dirname(current) +sys.path.append(parent) +from functions.pressure_conversion import pressure_conversion +from Turbinen.Turbinen_class_file import Francis_Turbine + +class Kraftwerk_class: + def __init__(self): + self.turbines = [] + + def add_turbine(self,turbine): + self.turbines.append(turbine) + + def print_info(self): + for turbine in self.turbines: + turbine.get_info(full=True) diff --git a/Kraftwerk/Kraftwerk_class_test.ipynb b/Kraftwerk/Kraftwerk_class_test.ipynb new file mode 100644 index 0000000..a820c4c --- /dev/null +++ b/Kraftwerk/Kraftwerk_class_test.ipynb @@ -0,0 +1,105 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "from Kraftwerk_class_file import Kraftwerk_class\n", + "\n", + "current = os.path.dirname(os.path.realpath('Main_Programm.ipynb'))\n", + "parent = os.path.dirname(current)\n", + "sys.path.append(parent)\n", + "from functions.pressure_conversion import pressure_conversion\n", + "from Turbinen.Turbinen_class_file import Francis_Turbine" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[, ]\n", + "Turbine has the following attributes: \n", + "----------------------------- \n", + "Type = Francis \n", + "Nominal flux = 0.85 m³/s \n", + "Nominal pressure = 108.09 mWS\n", + "Nominal LA = 100.0 % \n", + "Closing time = 500 s \n", + "Current flux = -1.0 m³/s \n", + "Current pipe pressure = -1.0 mWS \n", + "Current LA = -1.0 % \n", + "Simulation timestep = -1.0 s \n", + "----------------------------- \n", + "\n", + "Turbine has the following attributes: \n", + "----------------------------- \n", + "Type = Francis \n", + "Nominal flux = 0.85 m³/s \n", + "Nominal pressure = 108.09 mWS\n", + "Nominal LA = 100.0 % \n", + "Closing time = 500 s \n", + "Current flux = -1.0 m³/s \n", + "Current pipe pressure = -1.0 mWS \n", + "Current LA = -1.0 % \n", + "Simulation timestep = -1.0 s \n", + "----------------------------- \n", + "\n" + ] + } + ], + "source": [ + "#Turbine\n", + "Q_nenn = 0.85 # m³/s\n", + "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", + "closing_time = 500 #s\n", + "\n", + "T1 = Francis_Turbine(Q_nenn,p_nenn,closing_time)\n", + "T2 = Francis_Turbine(Q_nenn,p_nenn,closing_time)\n", + "\n", + "KW = Kraftwerk_class()\n", + "KW.add_turbine(T1)\n", + "KW.add_turbine(T2)\n", + "\n", + "print(KW.turbines)\n", + "\n", + "KW.print_info()" + ] + } + ], + "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 +} diff --git a/Regler/regler_test.ipynb b/Regler/Pegelregler_test.ipynb similarity index 59% rename from Regler/regler_test.ipynb rename to Regler/Pegelregler_test.ipynb index bad0931..081cd94 100644 --- a/Regler/regler_test.ipynb +++ b/Regler/Pegelregler_test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 34, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -23,15 +23,16 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "#define constants\n", "\n", "#Turbine\n", - "Q_nenn = 0.85\n", - "p_nenn,_ = pressure_conversion(10.6,'bar','Pa')\n", + "Q_nenn = 0.85 # m³/s\n", + "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", + "closing_time = 480. #s\n", "\n", "# physics\n", "g = 9.81 # gravitational acceleration [m/s²]\n", @@ -39,8 +40,8 @@ "\n", "# define controller constants\n", "target_level = 8. # m\n", - "Kp = 0.1\n", - "Ti = 100.\n", + "Kp = 0.01\n", + "Ti = 3600.\n", "deadband_range = 0.05 # m\n", "\n", "# reservoir\n", @@ -59,9 +60,9 @@ "h_fict = 100\n", "offset_pressure = rho*g*h_fict\n", "\n", - "t_max = 1e3 #s\n", - "nt = int(1e6) # number of simulation steps of reservoir in between timesteps of pipeline \n", - "dt = t_max/nt\n", + "t_max = 1e4 #s\n", + "dt = 1e-2 # simulation timestep\n", + "nt = int(t_max//dt) # number of simulation steps of reservoir in between timesteps of pipeline \n", "\n", "t_vec = np.arange(0,nt+1,1)*dt\n", "\n" @@ -69,25 +70,24 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# create objects\n", "\n", "V = Ausgleichsbecken_class(area_base,area_outflux,critical_level_low,critical_level_high,dt)\n", - "V.set_steady_state(initial_influx,initial_level,initial_pressure_unit,conversion_pressure_unit)\n", + "V.set_steady_state(initial_influx,initial_level,conversion_pressure_unit)\n", "\n", - "T1 = Francis_Turbine(Q_nenn,p_nenn)\n", + "T1 = Francis_Turbine(Q_nenn,p_nenn,closing_time,dt)\n", "T1.set_steady_state(initial_influx,p0+offset_pressure)\n", - "T1.set_closing_time(500)\n", "\n", "Pegelregler = PI_controller_class(target_level,deadband_range,Kp,Ti,dt)" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -96,12 +96,12 @@ "LA_soll_vec = np.full(nt+1,T1.LA)\n", "Q_vec = np.full(nt+1,initial_influx)\n", "\n", - "Pegelregler.control_variable = T1.LA" + "Pegelregler.control_variable = T1.get_current_LA()" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -109,106 +109,105 @@ "output_type": "stream", "text": [ "0.0\n", - "10.0\n", - "20.0\n", - "30.0\n", - "40.0\n", - "50.0\n", - "60.0\n", - "70.0\n", - "80.0\n", - "90.0\n", "100.0\n", - "110.0\n", - "120.0\n", - "130.0\n", - "140.0\n", - "150.0\n", - "160.0\n", - "170.0\n", - "180.0\n", - "190.0\n", "200.0\n", - "210.0\n", - "220.0\n", - "230.0\n", - "240.0\n", - "250.0\n", - "260.0\n", - "270.0\n", - "280.0\n", - "290.0\n", "300.0\n", - "310.0\n", - "320.0\n", - "330.0\n", - "340.0\n", - "350.0\n", - "360.0\n", - "370.0\n", - "380.0\n", - "390.0\n", "400.0\n", - "410.0\n", - "420.0\n", - "430.0\n", - "440.0\n", - "450.0\n", - "460.0\n", - "470.0\n", - "480.0\n", - "490.0\n", "500.0\n", - "510.0\n", - "520.0\n", - "530.0\n", - "540.0\n", - "550.0\n", - "560.0\n", - "570.0\n", - "580.0\n", - "590.0\n", "600.0\n", - "610.0\n", - "620.0\n", - "630.0\n", - "640.0\n", - "650.0\n", - "660.0\n", - "670.0\n", - "680.0\n", - "690.0\n", "700.0\n", - "710.0\n", - "720.0\n", - "730.0\n", - "740.0\n", - "750.0\n", - "760.0\n", - "770.0\n", - "780.0\n", - "790.0\n", "800.0\n", - "810.0\n", - "820.0\n", - "830.0\n", - "840.0\n", - "850.0\n", - "860.0\n", - "870.0\n", - "880.0\n", - "890.0\n", "900.0\n", - "910.0\n", - "920.0\n", - "930.0\n", - "940.0\n", - "950.0\n", - "960.0\n", - "970.0\n", - "980.0\n", - "990.0\n", - "1000.0\n" + "1000.0\n", + "1100.0\n", + "1200.0\n", + "1300.0\n", + "1400.0\n", + "1500.0\n", + "1600.0\n", + "1700.0\n", + "1800.0\n", + "1900.0\n", + "2000.0\n", + "2100.0\n", + "2200.0\n", + "2300.0\n", + "2400.0\n", + "2500.0\n", + "2600.0\n", + "2700.0\n", + "2800.0\n", + "2900.0\n", + "3000.0\n", + "3100.0\n", + "3200.0\n", + "3300.0\n", + "3400.0\n", + "3500.0\n", + "3600.0\n", + "3700.0\n", + "3800.0\n", + "3900.0\n", + "4000.0\n", + "4100.0\n", + "4200.0\n", + "4300.0\n", + "4400.0\n", + "4500.0\n", + "4600.0\n", + "4700.0\n", + "4800.0\n", + "4900.0\n", + "5000.0\n", + "5100.0\n", + "5200.0\n", + "5300.0\n", + "5400.0\n", + "5500.0\n", + "5600.0\n", + "5700.0\n", + "5800.0\n", + "5900.0\n", + "6000.0\n", + "6100.0\n", + "6200.0\n", + "6300.0\n", + "6400.0\n", + "6500.0\n", + "6600.0\n", + "6700.0\n", + "6800.0\n", + "6900.0\n", + "7000.0\n", + "7100.0\n", + "7200.0\n", + "7300.0\n", + "7400.0\n", + "7500.0\n", + "7600.0\n", + "7700.0\n", + "7800.0\n", + "7900.0\n", + "8000.0\n", + "8100.0\n", + "8200.0\n", + "8300.0\n", + "8400.0\n", + "8500.0\n", + "8600.0\n", + "8700.0\n", + "8800.0\n", + "8900.0\n", + "9000.0\n", + "9100.0\n", + "9200.0\n", + "9300.0\n", + "9400.0\n", + "9500.0\n", + "9600.0\n", + "9700.0\n", + "9800.0\n", + "9900.0\n" ] } ], @@ -220,31 +219,31 @@ " if np.mod(i,1e4) == 0:\n", " print(t_vec[i])\n", "\n", - " if t_vec[i] == 0.4*np.max(t_vec):\n", - " V.influx = 0\n", + " if i == 0.4*(nt+1):\n", + " V.set_influx(0.)\n", "\n", - " p = rho*g*V.level-0.5*rho*(V.outflux_vel)**2\n", - "\n", - " LA_soll = Pegelregler.get_control_variable(V.level)\n", - " T1.change_LA(LA_soll,dt)\n", + " p = V.get_current_pressure()\n", + " Pegelregler.update_control_variable(V.level)\n", + " LA_soll = Pegelregler.get_current_control_variable()\n", + " T1.update_LA(LA_soll)\n", + " T1.set_pressure(p+offset_pressure)\n", " LA_soll_vec[i] = LA_soll\n", - " LA_ist_vec[i] = T1.LA\n", - " Q_vec[i] = T1.get_Q(p+offset_pressure)\n", + " LA_ist_vec[i] = T1.get_current_LA()\n", + " Q_vec[i] = T1.get_current_Q()\n", "\n", - " V.pressure = p\n", - " V.outflux_vel = 1/V.area_outflux*Q_vec[i]\n", + " \n", + " V.set_outflux(Q_vec[i])\n", "\n", - " V.e_RK_4() \n", - " V.level = V.update_level(V.timestep) \n", - " V.set_volume() \n", - " level_vec[i] = V.level \n", + " V.timestep_reservoir_evolution() \n", + " \n", + " level_vec[i] = V.get_current_level()\n", " \n", " " ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -257,7 +256,7 @@ "axs1[0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs1[0].set_ylabel(r'$h$ [$\\mathrm{m}$]')\n", "axs1[0].plot(t_vec,level_vec)\n", - "axs1[0].set_ylim([0.85*initial_level,1.05*initial_level])\n", + "axs1[0].set_ylim([0*initial_level,1.5*initial_level])\n", "axs1[1].set_title('Flux')\n", "axs1[1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs1[1].set_ylabel(r'$Q$ [$\\mathrm{m} / \\mathrm{s}^3$]')\n", @@ -265,51 +264,33 @@ "axs1[1].set_ylim([0,2*initial_influx])\n", "axs1[2].set_title('LA')\n", "axs1[2].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "axs1[2].set_ylabel(r'$LA$ [\\%]')\n", + "axs1[2].set_ylabel(r'$LA$ [%]')\n", "axs1[2].plot(t_vec,LA_soll_vec)\n", "axs1[2].plot(t_vec,LA_ist_vec)\n", "axs1[2].set_ylim([0,1])\n", "fig1.tight_layout()\n", - "fig1.show()\n", - "plt.pause(1)" + "fig1.show()\n" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 40, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fig2 = plt.figure()\n", - "plt.plot(t_vec,Pegelregler.error_history[1:])" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[8. 8. 8. ... 7.21126138 7.21126138 7.21126138]\n" - ] - } - ], - "source": [ - "print(level_vec[:])" + "plt.plot(t_vec,Pegelregler.get_error_history())" ] } ], diff --git a/Regler/Regler_class_file.py b/Regler/Regler_class_file.py index c205257..dcbf58a 100644 --- a/Regler/Regler_class_file.py +++ b/Regler/Regler_class_file.py @@ -2,13 +2,13 @@ import numpy as np #based on https://en.wikipedia.org/wiki/PID_controller#Discrete_implementation def trap_int(vec,timestep): + # numerical integration via the trapeziod rule to calculate the performance parameters l = np.size(vec) int = 0 for i in range(l-1): int = int + (vec[i]+vec[i+1])/2*timestep return int - def ISE_fun(error_history,timestep): # calcuate the integral of square error e = np.array(error_history) @@ -74,61 +74,50 @@ class P_controller_class: class PI_controller_class: - def __init__(self,setpoint,deadband,proportionality_constant,Ti, timestep): +# init + def __init__(self,setpoint,deadband,proportionality_constant,Ti,timestep,lower_limit=0.,upper_limit=1.): self.SP = setpoint self.db = deadband self.Kp = proportionality_constant - self.Ti = Ti + self.Ti = Ti # integration time self.dt = timestep - self.error_history = [0] + # use a list to be able to append more easily - will get converted to np.array when needed + self.error_history = [0] - self.cv_lower_limit = 0 # default - self.cv_upper_limit = +1 # default + self.control_variable = -99 + self.cv_lower_limit = lower_limit # limits for the controll variable + self.cv_upper_limit = upper_limit # limits for the controll variable - def set_control_variable_limits(self,lower_limit,upper_limit): - self.cv_lower_limit = lower_limit - self.cv_upper_limit = upper_limit +# setter + def set_setpoint(self,setpoint): + self.SP = setpoint - def calculate_error(self,process_variable): - self.error = process_variable-self.SP - self.error_history.append(self.error) + def set_control_variable(self,control_variable, display_warning=True): + if display_warning == True and self.control_variable != -99: + print('WARNING! You are setting the control variable of the PI controller manually \ + and are not using the .update_controll_variable() method') + self.control_variable = control_variable - def get_control_variable(self,process_variable): - - self.calculate_error(process_variable) - - cv = self.control_variable - Kp = self.Kp - Ti = self.Ti - dt = self.dt - - e0 = self.error_history[-1] - e1 = self.error_history[-2] - if abs(self.error) > self.db: - new_control = cv+Kp*(e0-e1)+dt/Ti*e0 - else: - new_control = cv - - if new_control < self.cv_lower_limit: - new_control = self.cv_lower_limit - - if new_control > self.cv_upper_limit: - new_control = self.cv_upper_limit - self.control_variable = new_control +# getter + def get_current_control_variable(self): return self.control_variable + def get_error_history(self): + return self.error_history[1:] + def get_performance_indicators(self,ISE=True,IAE=True,ITSE=True,ITAE=True): + # calculate and return the performance indicators of the error history ise = np.nan iae = np.nan itse = np.nan itae = np.nan # self.error_history[1:] because the first value of the error history is set to [0] - # to avoid special case handling in the calculation of the controll variable - if ISE == True: + # to avoid special case handling in the calculation of the control variable + if ISE == True: ise = ISE_fun(self.error_history[1:],self.dt) - if IAE == True: + if IAE == True: iae = IAE_fun(self.error_history[1:],self.dt) if ITSE == True: itse = ITSE_fun(self.error_history[1:],self.dt) @@ -137,4 +126,58 @@ class PI_controller_class: return ise,iae,itse,itae + def get_info(self): + new_line = '\n' + # :<10 pads the self.value to be 10 characters wide + print_str = (f"Turbine has the following attributes: {new_line}" + f"----------------------------- {new_line}" + f"Type = PI Controller {new_line}" + f"Setpoint = {self.SP:<10} {new_line}" + f"Deadband = {self.db:<10} {new_line}" + f"Proportionality constant = {self.Kp:<10} {new_line}" + f"Integration time = {self.Ti:<10} [s] {new_line}" + f"Current control variable = {round(self.control_variable,3):<10} {new_line}" + f"Lower limit CV = {self.cv_lower_limit:<10} {new_line}" + f"Upper limit CV = {self.cv_upper_limit:<10} {new_line}" + f"Simulation timestep = {self.dt:<10} [s] {new_line}" + f"----------------------------- {new_line}") + + print(print_str) + +# methods + def calculate_error(self,process_variable): + # calculate the error and expand the err history + self.error = process_variable-self.SP + self.error_history.append(self.error) + + def update_control_variable(self,process_variable): + # calculate the current control variable and make sure it does not exceed the limits + self.calculate_error(process_variable) + + # initialize some variables + cv = self.control_variable + Kp = self.Kp + Ti = self.Ti + dt = self.dt + + e0 = self.error_history[-1] + e1 = self.error_history[-2] + + # test if the error exceeds the deadband range + # only if that is the case, change control variable + if abs(self.error) > self.db: + new_control = cv+Kp*(e0-e1)+dt/Ti*e0 + else: + new_control = cv + + # ensure that the controll variable stays within the predefined limits + if new_control < self.cv_lower_limit: + new_control = self.cv_lower_limit + if new_control > self.cv_upper_limit: + new_control = self.cv_upper_limit + + # set the control variable attribute + self.set_control_variable(new_control,display_warning=False) + + diff --git a/Turbinen/Turbinen_class_file.py b/Turbinen/Turbinen_class_file.py index 842b345..e1b3d5a 100644 --- a/Turbinen/Turbinen_class_file.py +++ b/Turbinen/Turbinen_class_file.py @@ -1,3 +1,4 @@ +from time import time import numpy as np #importing pressure conversion function import sys @@ -8,35 +9,117 @@ sys.path.append(parent) from functions.pressure_conversion import pressure_conversion class Francis_Turbine: - def __init__(self, Q_nenn,p_nenn): - self.Q_n = Q_nenn - self.p_n = p_nenn - self.LA_n = 1. # 100% - h = pressure_conversion(p_nenn,'Pa','MWs') - self.A = Q_nenn/(np.sqrt(2*9.81*h)*0.98) + # units + # make sure that units and print units are the same + # units are used to label graphs and print units are used to have a bearable format when using pythons print() + density_unit = r'$\mathrm{kg}/\mathrm{m}^3$' + flux_unit = r'$\mathrm{m}^3/\mathrm{s}$' + LA_unit = '%' + pressure_unit = 'Pa' + time_unit = 's' + velocity_unit = r'$\mathrm{m}/\mathrm{s}$' + volume_unit = r'$\mathrm{m}^3$' - def set_LA(self,LA): + density_unit_print = 'kg/m³' + flux_unit_print = 'm³/s' + LA_unit_print = '%' + pressure_unit_print = 'mWS' + time_unit_print = 's' + velocity_unit_print = 'm/s' + volume_unit_print = 'm³' + + g = 9.81 # m/s² gravitational acceleration + + # init + def __init__(self, Q_nenn,p_nenn,t_closing=-1.,timestep=-1.): + self.Q_n = Q_nenn # nominal flux + self.p_n = p_nenn # nominal pressure + self.LA_n = 1. # 100% # nominal Leitapparatöffnung + h = pressure_conversion(p_nenn,'Pa','MWs') # nominal pressure in terms of hydraulic head + self.A = Q_nenn/(np.sqrt(2*self.g*h)*0.98) # Ersatzfläche + + self.dt = timestep # simulation timestep + self.t_c = t_closing # closing time + self.d_LA_max_dt = 1/t_closing # maximal change of LA per second + + # initialize for get_info() - parameters will be converted to display -1 if not overwritten + self.p = pressure_conversion(-1,self.pressure_unit_print,self.pressure_unit) + self.Q = -1. + self.LA = -0.01 + + +# setter + def set_LA(self,LA,display_warning=True): + # set Leitapparatöffnung self.LA = LA + # warn user, that the .set_LA() method should not be used ot set LA manually + if display_warning == True: + print('Consider using the .update_LA() method instead of setting LA manually') + + def set_timestep(self,timestep,display_warning=True): + # set Leitapparatöffnung + self.dt = time + # warn user, that the .set_LA() method should not be used ot set LA manually + if display_warning == True: + print('WARNING: You are changing the timestep of the turbine simulation. This has implications on the simulated closing speed!') + def set_pressure(self,pressure): + # set pressure in front of the turbine self.p = pressure - def get_Q(self): +#getter + def get_current_Q(self): + # return the flux through the turbine, based on the current pressure in front + # of the turbine and the Leitapparatöffnung self.Q = self.Q_n*(self.LA/self.LA_n)*np.sqrt(self.p/self.p_n) return self.Q - def set_closing_time(self,t_closing): - self.t_c = t_closing - self.d_LA_max_dt = 1/t_closing + def get_current_LA(self): + return self.LA - def change_LA(self,LA_soll,timestep): - LA_diff = self.LA-LA_soll - LA_diff_max = self.d_LA_max_dt*timestep - if abs(LA_diff) > LA_diff_max: - LA_diff = np.sign(LA_diff)*LA_diff_max - self.LA = self.LA-LA_diff + def get_info(self, full = False): + new_line = '\n' + p = pressure_conversion(self.p,self.pressure_unit,self.pressure_unit_print) + p_n = pressure_conversion(self.p_n,self.pressure_unit,self.pressure_unit_print) + + + if full == True: + # :<10 pads the self.value to be 10 characters wide + print_str = (f"Turbine has the following attributes: {new_line}" + f"----------------------------- {new_line}" + f"Type = Francis {new_line}" + f"Nominal flux = {self.Q_n:<10} {self.flux_unit_print} {new_line}" + f"Nominal pressure = {round(p_n,3):<10} {self.pressure_unit_print}{new_line}" + f"Nominal LA = {self.LA_n*100:<10} {self.LA_unit_print} {new_line}" + f"Closing time = {self.t_c:<10} {self.time_unit_print} {new_line}" + f"Current flux = {self.Q:<10} {self.flux_unit_print} {new_line}" + f"Current pipe pressure = {round(p,3):<10} {self.pressure_unit_print} {new_line}" + f"Current LA = {self.LA*100:<10} {self.LA_unit_print} {new_line}" + f"Simulation timestep = {self.dt:<10} {self.time_unit_print} {new_line}" + f"----------------------------- {new_line}") + else: + # :<10 pads the self.value to be 10 characters wide + print_str = (f"The current attributes are: {new_line}" + f"----------------------------- {new_line}" + f"Current flux = {self.Q:<10} {self.flux_unit_print} {new_line}" + f"Current pipe pressure = {round(p,3):<10} {self.pressure_unit_print} {new_line}" + f"Current LA = {self.LA*100:<10} {self.LA_unit_print} {new_line}" + f"----------------------------- {new_line}") + + print(print_str) + +# methods + def update_LA(self,LA_soll): + # update the Leitappartöffnung and consider the restrictions of the closing time of the turbine + LA_diff = self.LA-LA_soll # calculate the difference to the target LA + LA_diff_max = self.d_LA_max_dt*self.dt # calculate the maximum change in LA based on the given timestep + LA_diff = np.sign(LA_diff)*np.min(np.abs([LA_diff,LA_diff_max])) # calulate the correct change in LA + self.set_LA(self.LA-LA_diff,display_warning=False) # set new LA def set_steady_state(self,ss_flux,ss_pressure): + # calculate and set steady state LA, that allows the flow of ss_flux at ss_pressure through the + # turbine at the steady state LA ss_LA = self.LA_n*ss_flux/self.Q_n*np.sqrt(self.p_n/ss_pressure) - self.set_LA(ss_LA) if ss_LA < 0 or ss_LA > 1: - print('LA out of range') + raise Exception('LA out of range [0;1]') + self.set_LA(ss_LA,display_warning=False) diff --git a/Turbinen/Turbinen_test.ipynb b/Turbinen/Turbinen_test_Kennlinie.ipynb similarity index 99% rename from Turbinen/Turbinen_test.ipynb rename to Turbinen/Turbinen_test_Kennlinie.ipynb index 7cfe0c3..5fdb785 100644 --- a/Turbinen/Turbinen_test.ipynb +++ b/Turbinen/Turbinen_test_Kennlinie.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -23,18 +23,39 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Turbine has the following attributes: \n", + "----------------------------- \n", + "Type = Francis \n", + "Nominal flux = 0.85 m³/s \n", + "Nominal pressure = 108.09 mWS\n", + "Nominal LA = 100.0 % \n", + "Closing time = -1 s \n", + "Current flux = -1 m³/s \n", + "Current pipe pressure = -1.0 mWS \n", + "Current LA = -1.0 % \n", + "Simulation timestep = -1 s \n", + "----------------------------- \n", + "\n" + ] + } + ], "source": [ "Q_nenn = 0.85\n", "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", - "Untertweng1 = Francis_Turbine(Q_nenn,p_nenn)" + "Untertweng1 = Francis_Turbine(Q_nenn,p_nenn)\n", + "Untertweng1.get_info(full=True)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -47,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -56,14 +77,14 @@ "Text(0.5, 0, 'Q [m³/s]')" ] }, - "execution_count": 20, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7650cd2a1f9a4b87b98e70add29f11a7", + "model_id": "75adb3cb47e642e3a5606cb41efedf72", "version_major": 2, "version_minor": 0 }, @@ -94,8 +115,8 @@ "for i in range(n_p):\n", " for j in range(n_LA):\n", " Untertweng1.set_pressure(pp[i,j])\n", - " Untertweng1.set_LA(ll[i,j])\n", - " Q_mat[i,j] = Untertweng1.get_Q()\n", + " Untertweng1.set_LA(ll[i,j],display_warning=False)\n", + " Q_mat[i,j] = Untertweng1.get_current_Q()\n", "\n", "fig1 = plt.figure()\n", "ax1 = plt.axes(projection='3d')\n", @@ -108,31 +129,23 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 8, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\BRANT\\AppData\\Local\\Temp\\9\\ipykernel_7508\\1599598770.py:5: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`).\n", - " fig = plt.figure()\n" - ] - }, { "data": { "text/plain": [ "(0.0, 1.275)" ] }, - "execution_count": 27, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "52152d0b96c74a4ebfb18041a22d8d0e", + "model_id": "224f00f9bf85446b845685a08ed27c68", "version_major": 2, "version_minor": 0 }, @@ -170,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -179,14 +192,14 @@ "(0.0, 1.275)" ] }, - "execution_count": 30, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bf6b0fe84d264693813f6e991600ece1", + "model_id": "92741b823c9749c9820ee7b5ba47a6bc", "version_major": 2, "version_minor": 0 }, @@ -221,23 +234,6 @@ "plt.title('P = '+ str(p_test2) + ' [Pa]')\n", "plt.ylim([0,1.5*Q_nenn])" ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "53000.0\n" - ] - } - ], - "source": [ - "print(pp[10,5])" - ] } ], "metadata": { diff --git a/Turbinen/messy.ipynb b/Turbinen/messy.ipynb new file mode 100644 index 0000000..d9e0b09 --- /dev/null +++ b/Turbinen/messy.ipynb @@ -0,0 +1,90 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from Turbinen_class_file import Francis_Turbine\n", + "from mpl_toolkits import mplot3d\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib widget\n", + "\n", + "#importing pressure conversion function\n", + "import sys\n", + "import os\n", + "current = os.path.dirname(os.path.realpath('messy.ipynb'))\n", + "parent = os.path.dirname(current)\n", + "sys.path.append(parent)\n", + "from functions.pressure_conversion import pressure_conversion" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current attributes are: \n", + "----------------------------- \n", + "Current flux = -1.0 m³/s \n", + "Current pipe pressure = -1.0 mWS \n", + "Current LA = -1.0 % \n", + "----------------------------- \n", + "\n", + "The current attributes are: \n", + "----------------------------- \n", + "Current flux = -1.0 m³/s \n", + "Current pipe pressure = -1.0 mWS \n", + "Current LA = -1.0 % \n", + "----------------------------- \n", + "\n" + ] + } + ], + "source": [ + "Q_nenn = 0.85\n", + "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", + "Untertweng1 = Francis_Turbine(Q_nenn,p_nenn)\n", + "Untertweng2 = Francis_Turbine(Q_nenn,p_nenn)\n", + "\n", + "\n", + "turbines = [Untertweng1,Untertweng2]\n", + "for turbine in turbines:\n", + " turbine.get_info()" + ] + } + ], + "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 +} diff --git a/Untertweng.ipynb b/Untertweng.ipynb index b2baf53..9eedd6d 100644 --- a/Untertweng.ipynb +++ b/Untertweng.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -17,15 +17,16 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#define constants\n", "\n", "#Turbine\n", - "Q_nenn = 0.85\n", - "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", + "Q_nenn = 0.85 # m³/s\n", + "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", + "closing_time = 30 #s\n", "\n", "# physics\n", "g = 9.81 # gravitational acceleration [m/s²]\n", @@ -37,35 +38,31 @@ "A_pipe = D**2/4*np.pi # pipeline area\n", "h_pipe = 105 # hydraulic head without reservoir [m] \n", "alpha = np.arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \n", - "n = 50 # number of pipe segments in discretization\n", + "n = 200 # number of pipe segments in discretization\n", "# consider replacing Q0 with a vector be be more flexible in initial conditions\n", "# Q0 = Q_nenn # initial flow in whole pipe [m³/s]\n", "# v0 = Q0/A_pipe # initial flow velocity [m/s]\n", "f_D = 0.014 # Darcy friction factor\n", "c = 500. # propagation velocity of the pressure wave [m/s]\n", "# consider prescribing a total simulation time and deducting the number of timesteps from that\n", - "nt = 3000 # number of time steps after initial conditions\n", + "nt = 20000 # number of time steps after initial conditions\n", "\n", "# derivatives of the pipeline constants\n", "dx = L/n # length of each pipe segment\n", "dt = dx/c # timestep according to method of characterisitics\n", "nn = n+1 # number of nodes\n", "initial_level = 8. # water level in upstream reservoir [m]\n", - "# p0 = rho*g*initial_level-v0**2*rho/2\n", - "pl_vec = np.arange(0,nn*dx,dx) # pl = pipe-length. position of the nodes on the pipeline\n", + "pl_vec = np.arange(0,nn,1)*dx # pl = pipe-length. position of the nodes on the pipeline\n", "t_vec = np.arange(0,nt+1)*dt # time vector\n", - "h_vec = np.arange(0,n+1)*h_pipe/n # hydraulic head of pipeline at each node \n", - "# v_init = np.full(nn,Q0/(D**2/4*np.pi)) # initial velocity distribution in pipeline\n", - "# p_init = (rho*g*(initial_level+h_vec)-v_init**2*rho/2)-(f_D*pl_vec/D*rho/2*v_init**2) # ref Wikipedia: Darcy Weisbach\n", + "h_vec = np.arange(0,nn,1)*h_pipe/n # hydraulic head of pipeline at each node \n", + "\n", "\n", "\n", "# reservoir\n", "# replace influx by vector\n", - "initial_influx = Q_nenn/1.1 # initial influx of volume to the reservoir [m³/s]\n", - "# initial_outflux = Q0 # initial outflux of volume from the reservoir to the pipeline [m³/s]\n", - "# initial_pipeline_pressure = p0 # Initial condition for the static pipeline pressure at the reservoir (= hydrostatic pressure - dynamic pressure) \n", + "initial_flux = Q_nenn/1.1 # initial influx of volume to the reservoir [m³/s]\n", "initial_pressure_unit = 'Pa' # DO NOT CHANGE! for pressure conversion in print statements and plot labels \n", - "conversion_pressure_unit = 'bar' # for pressure conversion in print statements and plot labels\n", + "conversion_pressure_unit = 'bar' # for pressure conversion in print statements and plot labels\n", "area_base = 74. # total base are of the cuboid reservoir [m²] \n", "area_outflux = A_pipe # outlfux area of the reservoir, given by pipeline area [m²]\n", "critical_level_low = 0. # for yet-to-be-implemented warnings[m]\n", @@ -78,43 +75,28 @@ "\n" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Ideas for checks after constant definitions: \n", - "\n", - "- Check that the initial pressure is not negative:\n", - " - may happen, if there is too little hydraulic head to create the initial flow conditions with the given friction\n", - "
\n", - "
\n", - "- plausbility checks?\n", - " - area > area_outflux ?\n", - " - propable ranges for parameters?\n", - " - angle and height/length fit together?\n", - " " - ] - }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# create objects\n", "\n", "V = Ausgleichsbecken_class(area_base,area_outflux,critical_level_low,critical_level_high,simulation_timestep)\n", - "V.set_steady_state(initial_influx,initial_level,conversion_pressure_unit)\n", + "V.set_steady_state(initial_flux,initial_level,conversion_pressure_unit)\n", + "\n", "\n", "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", "pipe.set_pressure_propagation_velocity(c)\n", "pipe.set_number_of_timesteps(nt)\n", - "pipe.set_steady_state(initial_influx,V.level,pl_vec,h_vec)\n", + "pipe.set_steady_state(initial_flux,initial_level,pl_vec,h_vec)\n", "\n", + "initial_pressure_turbine = pipe.get_current_pressure_distribution()[-1]\n", + "\n", + "T1 = Francis_Turbine(Q_nenn,p_nenn,closing_time,timestep = dt)\n", + "T1.set_steady_state(initial_flux,initial_pressure_turbine)\n", "\n", - "T1 = Francis_Turbine(Q_nenn,p_nenn)\n", - "T1.set_steady_state(initial_influx,pipe.p0[-1])\n", - "T1.set_closing_time(30)\n", "\n", "# display the attributes of the created reservoir and pipeline object\n", "# V.get_info(full=True)\n", @@ -123,19 +105,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# initialization for timeloop\n", "\n", "# prepare the vectors in which the pressure and velocity distribution in the pipeline from the previous timestep are stored\n", - "v_old = pipe.v0.copy()\n", - "p_old = pipe.p0.copy()\n", + "v_old = pipe.get_current_velocity_distribution()\n", + "p_old = pipe.get_current_pressure_distribution()\n", "\n", "# prepare the vectors in which the temporal evolution of the boundary conditions are stored\n", - " # keep in mind, that the velocity at the turbine and the pressure at the reservoir are set manually and\n", - " # through the time evolution of the reservoir respectively \n", + " # keep in mind, that the velocity at the turbine and the pressure at the reservoir follow from boundary conditions\n", + " # reservoir level and flow through turbine\n", " # the pressure at the turbine and the velocity at the reservoir are calculated from the method of characteristics\n", "v_boundary_res = np.zeros_like(t_vec)\n", "v_boundary_tur = np.zeros_like(t_vec)\n", @@ -143,8 +125,7 @@ "p_boundary_tur = np.zeros_like(t_vec)\n", "\n", "# prepare the vectors that store the temporal evolution of the level in the reservoir\n", - "level_vec = np.full(nt+1,V.level) # level at the end of each pipeline timestep\n", - "level_vec_2 = np.zeros([nt_eRK4]) # level throughout each reservoir timestep-used for plotting and overwritten afterwards\n", + "level_vec = np.full(nt+1,initial_level) # level at the end of each pipeline timestep\n", "\n", "# set the boundary conditions for the first timestep\n", "v_boundary_res[0] = v_old[0]\n", @@ -153,14 +134,15 @@ "p_boundary_tur[0] = p_old[-1]\n", "\n", "LA_soll_vec = np.full_like(t_vec,T1.LA)\n", - "LA_soll_vec[1500:]= 0\n", + "LA_soll_vec[500:]= 0\n", + "LA_ist_vec = np.full_like(t_vec,T1.LA)\n", "\n", "\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -176,16 +158,11 @@ "axs1[0].set_ylabel(r'$p$ ['+conversion_pressure_unit+']')\n", "axs1[1].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", "axs1[1].set_ylabel(r'$v$ [$\\mathrm{m} / \\mathrm{s}$]')\n", - "lo_00, = axs1[0].plot(pl_vec,pressure_conversion(pipe.p_old,initial_pressure_unit, conversion_pressure_unit),marker='.')\n", - "lo_01, = axs1[1].plot(pl_vec,pipe.v_old,marker='.')\n", + "lo_00, = axs1[0].plot(pl_vec,pressure_conversion(p_old,initial_pressure_unit, conversion_pressure_unit),marker='.')\n", + "lo_01, = axs1[1].plot(pl_vec,v_old,marker='.')\n", "axs1[0].autoscale()\n", "axs1[1].autoscale()\n", - "# displaying the reservoir level within each pipeline timestep\n", - "# axs1[2].set_title('Level reservoir')\n", - "# axs1[2].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "# axs1[2].set_ylabel(r'$h$ [m]')\n", - "# lo_02, = axs1[2].plot(level_vec_2)\n", - "# axs1[2].autoscale()\n", + "\n", "fig1.tight_layout()\n", "fig1.show()\n", "plt.pause(1)\n" @@ -193,60 +170,62 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# loop through time steps of the pipeline\n", "for it_pipe in range(1,pipe.nt+1):\n", "\n", + " if t_vec[it_pipe]>20:\n", + " if V.get_current_influx() > 0:\n", + " V.set_influx(np.max([V.get_current_influx()-initial_flux*5*1e-3,0.]))\n", + "\n", "# for each pipeline timestep, execute nt_eRK4 timesteps of the reservoir code\n", " # set initial conditions for the reservoir time evolution calculted with e-RK4\n", - " V.pressure = p_old[0]\n", - " V.outflux_vel = v_old[0]\n", + " V.set_pressure = p_old[0]\n", + " V.set_outflux = v_old[0]*area_outflux\n", " # calculate the time evolution of the reservoir level within each pipeline timestep to avoid runaway numerical error\n", " for it_res in range(nt_eRK4):\n", - " V.e_RK_4() # call e-RK4 to update outflux\n", - " V.level = V.update_level(V.timestep) # \n", - " V.update_volume() # update volume in reservoir\n", - " level_vec_2[it_res] = V.level # save for plotting\n", - " if (V.level < critical_level_low) or (V.level > critical_level_high): # make sure to never exceed critical levels\n", - " i_max = it_pipe # for plotting only calculated values\n", - " break \n", - " level_vec[it_pipe] = V.level \n", + " V.timestep_reservoir_evolution() \n", + " level_vec[it_pipe] = V.get_current_level() \n", + "\n", + " # change the Leitapparatöffnung based on the target value\n", + " T1.update_LA(LA_soll_vec[it_pipe])\n", + " T1.set_pressure(p_old[-1])\n", + "\n", + " LA_ist_vec[it_pipe] = T1.LA\n", "\n", " # set boundary conditions for the next timestep of the characteristic method\n", - " p_boundary_res[it_pipe] = rho*g*V.level-V.outflux_vel**2*rho/2\n", - "\n", - " T1.change_LA(LA_soll_vec[it_pipe],dt)\n", - " v_boundary_tur[it_pipe] = 1/A_pipe*T1.get_Q(p_old[-1])\n", + " p_boundary_res[it_pipe] = V.get_current_pressure()\n", + " v_boundary_tur[it_pipe] = 1/A_pipe*T1.get_current_Q()\n", "\n", " # the the boundary conditions in the pipe.object and thereby calculate boundary pressure at turbine\n", " pipe.set_boundary_conditions_next_timestep(p_boundary_res[it_pipe],v_boundary_tur[it_pipe])\n", - " p_boundary_tur[it_pipe] = pipe.p_boundary_tur\n", - " v_boundary_res[it_pipe] = pipe.v_boundary_res\n", + " p_boundary_tur[it_pipe] = pipe.get_current_pressure_distribution()[-1]\n", + " v_boundary_res[it_pipe] = pipe.get_current_velocity_distribution()[0]\n", "\n", " # perform the next timestep via the characteristic method\n", " pipe.timestep_characteristic_method()\n", "\n", + " # prepare for next loop\n", + " p_old = pipe.get_current_pressure_distribution()\n", + " v_old = pipe.get_current_velocity_distribution()\n", + "\n", " # plot some stuff\n", " # remove line-objects to autoscale axes (there is definetly a better way, but this works ¯\\_(ツ)_/¯ )\n", " lo_00.remove()\n", " lo_01.remove()\n", " # lo_02.remove()\n", " # plot new pressure and velocity distribution in the pipeline\n", - " lo_00, = axs1[0].plot(pl_vec,pressure_conversion(pipe.p_old,initial_pressure_unit, conversion_pressure_unit),marker='.',c='blue')\n", - " lo_01, = axs1[1].plot(pl_vec,pipe.v_old,marker='.',c='blue')\n", + " lo_00, = axs1[0].plot(pl_vec,pressure_conversion(p_old,initial_pressure_unit, conversion_pressure_unit),marker='.',c='blue')\n", + " lo_01, = axs1[1].plot(pl_vec,v_old,marker='.',c='blue')\n", " # lo_02, = axs1[2].plot(level_vec_2,c='blue')\n", " fig1.suptitle(str(round(t_vec[it_pipe],2))+ ' s / '+str(round(t_vec[-1],2)) + ' s' )\n", " fig1.canvas.draw()\n", " fig1.tight_layout()\n", " fig1.show()\n", - " plt.pause(0.1) \n", - "\n", - " # prepare for next loop\n", - " p_old = pipe.p_old\n", - " v_old = pipe.v_old \n", + " plt.pause(0.001) \n", "\n", " \n", " " @@ -254,35 +233,44 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# plot time evolution of boundary pressure and velocity as well as the reservoir level\n", "\n", "fig2,axs2 = plt.subplots(3,2)\n", - "axs2[0,0].plot(t_vec,pressure_conversion(p_boundary_res,initial_pressure_unit, conversion_pressure_unit))\n", - "axs2[0,1].plot(t_vec,v_boundary_res)\n", - "axs2[0,1].set_ylim(-2*Q_nenn,+2*Q_nenn)\n", - "axs2[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,initial_pressure_unit, conversion_pressure_unit))\n", - "axs2[1,1].plot(t_vec,v_boundary_tur)\n", - "axs2[2,0].plot(t_vec,level_vec)\n", "axs2[0,0].set_title('Pressure reservoir')\n", - "axs2[0,1].set_title('Velocity reservoir')\n", - "axs2[1,0].set_title('Pressure turbine')\n", - "axs2[1,1].set_title('Velocity turbine')\n", - "axs2[2,0].set_title('Level reservoir')\n", + "axs2[0,0].plot(t_vec,pressure_conversion(p_boundary_res,initial_pressure_unit, conversion_pressure_unit))\n", "axs2[0,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs2[0,0].set_ylabel(r'$p$ ['+conversion_pressure_unit+']')\n", + "\n", + "axs2[0,1].set_title('Velocity reservoir')\n", + "axs2[0,1].plot(t_vec,v_boundary_res)\n", + "axs2[0,1].set_ylim(-2*Q_nenn,+2*Q_nenn)\n", "axs2[0,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs2[0,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "\n", + "axs2[1,0].set_title('Pressure turbine')\n", + "axs2[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,initial_pressure_unit, conversion_pressure_unit))\n", "axs2[1,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs2[1,0].set_ylabel(r'$p$ ['+conversion_pressure_unit+']')\n", + "\n", + "axs2[1,1].set_title('Velocity turbine')\n", + "axs2[1,1].plot(t_vec,v_boundary_tur)\n", "axs2[1,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs2[1,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "\n", + "axs2[2,0].set_title('Level reservoir')\n", + "axs2[2,0].plot(t_vec,level_vec)\n", "axs2[2,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs2[2,0].set_ylabel(r'$h$ [m]')\n", - "axs2[2,1].axis('off')\n", + "\n", + "axs2[2,1].set_title('LA')\n", + "axs2[2,1].plot(t_vec,100*LA_soll_vec)\n", + "axs2[2,1].plot(t_vec,100*LA_ist_vec)\n", + "axs2[2,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[2,1].set_ylabel(r'$LA$ [%]')\n", "fig2.tight_layout()\n", "plt.show()" ] diff --git a/Untertweng_mit_Pegelregler.ipynb b/Untertweng_mit_Pegelregler.ipynb index 0d5d5e7..8c4669e 100644 --- a/Untertweng_mit_Pegelregler.ipynb +++ b/Untertweng_mit_Pegelregler.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 22, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -18,20 +18,29 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "#define constants\n", "\n", "#Turbine\n", - "Q_nenn = 0.85\n", - "p_nenn,_ = pressure_conversion(10.6,'bar','Pa')\n", + "Q_nenn = 0.85 # m³/s\n", + "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", + "closing_time = 70 #s\n", "\n", "# physics\n", "g = 9.81 # gravitational acceleration [m/s²]\n", "rho = 1000. # density of water [kg/m³]\n", "\n", + "\n", + "# define controller constants\n", + "target_level = 8. # m\n", + "Kp = 0.1\n", + "Ti = 10.\n", + "deadband_range = 0.05 # m\n", + "\n", + "\n", "# pipeline\n", "L = 535.+478. # length of pipeline [m]\n", "D = 0.9 # pipe diameter [m]\n", @@ -42,34 +51,29 @@ "f_D = 0.014 # Darcy friction factor\n", "c = 500. # propagation velocity of the pressure wave [m/s]\n", "# consider prescribing a total simulation time and deducting the number of timesteps from that\n", - "nt = 1500 # number of time steps after initial conditions\n", + "nt = 1000 # number of time steps after initial conditions\n", "\n", "# derivatives of the pipeline constants\n", "dx = L/n # length of each pipe segment\n", "dt = dx/c # timestep according to method of characterisitics\n", "nn = n+1 # number of nodes\n", - "initial_level = 8. # water level in upstream reservoir [m]\n", - "pl_vec = np.arange(0,nn*dx,dx) # pl = pipe-length. position of the nodes on the pipeline\n", + "initial_level = target_level # water level in upstream reservoir [m]\n", + "pl_vec = np.arange(0,nn,1)*dx # pl = pipe-length. position of the nodes on the pipeline\n", "t_vec = np.arange(0,nt+1)*dt # time vector\n", - "h_vec = np.arange(0,n+1)*h_pipe/n # hydraulic head of pipeline at each node \n", + "h_vec = np.arange(0,nn,1)*h_pipe/n # hydraulic head of pipeline at each node \n", + "\n", + "\n", "\n", "# reservoir\n", "# replace influx by vector\n", - "initial_influx = Q_nenn/1.1 # initial influx of volume to the reservoir [m³/s]\n", + "initial_flux = Q_nenn/1.1 # initial influx of volume to the reservoir [m³/s]\n", "initial_pressure_unit = 'Pa' # DO NOT CHANGE! for pressure conversion in print statements and plot labels \n", - "conversion_pressure_unit = 'bar' # for pressure conversion in print statements and plot labels\n", + "conversion_pressure_unit = 'bar' # for pressure conversion in print statements and plot labels\n", "area_base = 74. # total base are of the cuboid reservoir [m²] \n", "area_outflux = A_pipe # outlfux area of the reservoir, given by pipeline area [m²]\n", "critical_level_low = 0. # for yet-to-be-implemented warnings[m]\n", "critical_level_high = np.inf # for yet-to-be-implemented warnings[m]\n", "\n", - "\n", - "# define controller constants\n", - "target_level = initial_level # m\n", - "Kp = 2\n", - "Ti = 10\n", - "deadband_range = 0.05 # m\n", - "\n", "# make sure e-RK4 method of reservoir has a small enough timestep to avoid runaway numerical error\n", "nt_eRK4 = 1000 # number of simulation steps of reservoir in between timesteps of pipeline \n", "simulation_timestep = dt/nt_eRK4\n", @@ -77,75 +81,55 @@ "\n" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Ideas for checks after constant definitions: \n", - "\n", - "- Check that the initial pressure is not negative:\n", - " - may happen, if there is too little hydraulic head to create the initial flow conditions with the given friction\n", - "
\n", - "
\n", - "- plausbility checks?\n", - " - area > area_outflux ?\n", - " - propable ranges for parameters?\n", - " - angle and height/length fit together?\n", - " " - ] - }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# create objects\n", "\n", "V = Ausgleichsbecken_class(area_base,area_outflux,critical_level_low,critical_level_high,simulation_timestep)\n", - "V.set_steady_state(initial_influx,initial_level,initial_pressure_unit,conversion_pressure_unit)\n", + "V.set_steady_state(initial_flux,initial_level,conversion_pressure_unit)\n", + "\n", "\n", "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", "pipe.set_pressure_propagation_velocity(c)\n", "pipe.set_number_of_timesteps(nt)\n", - "pipe.set_steady_state(initial_influx,V.level,pl_vec,h_vec,initial_pressure_unit,conversion_pressure_unit)\n", + "pipe.set_steady_state(initial_flux,initial_level,pl_vec,h_vec)\n", "\n", + "initial_pressure_turbine = pipe.get_current_pressure_distribution()[-1]\n", "\n", - "T1 = Francis_Turbine(Q_nenn,p_nenn)\n", - "T1.set_steady_state(initial_influx,pipe.p0[-1])\n", - "T1.set_closing_time(5)\n", + "T1 = Francis_Turbine(Q_nenn,p_nenn,closing_time,timestep = dt)\n", + "T1.set_steady_state(initial_flux,initial_pressure_turbine)\n", "\n", "Pegelregler = PI_controller_class(target_level,deadband_range,Kp,Ti,dt)\n", - "\n", - "# display the attributes of the created reservoir and pipeline object\n", - "# V.get_info(full=True)\n", - "# pipe.get_info()" + "Pegelregler.control_variable = T1.get_current_LA()\n" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "# initialization for timeloop\n", "\n", "# prepare the vectors in which the pressure and velocity distribution in the pipeline from the previous timestep are stored\n", - "v_old = pipe.v0.copy()\n", - "p_old = pipe.p0.copy()\n", + "v_old = pipe.get_current_velocity_distribution()\n", + "p_old = pipe.get_current_pressure_distribution()\n", "\n", "# prepare the vectors in which the temporal evolution of the boundary conditions are stored\n", - " # keep in mind, that the velocity at the turbine and the pressure at the reservoir are set manually and\n", - " # through the time evolution of the reservoir respectively \n", + " # keep in mind, that the velocity at the turbine and the pressure at the reservoir follow from boundary conditions\n", + " # reservoir level and flow through turbine\n", " # the pressure at the turbine and the velocity at the reservoir are calculated from the method of characteristics\n", - "v_boundary_res = np.empty_like(t_vec)\n", - "v_boundary_tur = np.empty_like(t_vec)\n", - "p_boundary_res = np.empty_like(t_vec)\n", - "p_boundary_tur = np.empty_like(t_vec)\n", + "v_boundary_res = np.zeros_like(t_vec)\n", + "v_boundary_tur = np.zeros_like(t_vec)\n", + "p_boundary_res = np.zeros_like(t_vec)\n", + "p_boundary_tur = np.zeros_like(t_vec)\n", "\n", "# prepare the vectors that store the temporal evolution of the level in the reservoir\n", - "level_vec = np.full(nt+1,V.level) # level at the end of each pipeline timestep\n", - "level_vec_2 = np.empty([nt_eRK4]) # level throughout each reservoir timestep-used for plotting and overwritten afterwards\n", + "level_vec = np.full(nt+1,initial_level) # level at the end of each pipeline timestep\n", "\n", "# set the boundary conditions for the first timestep\n", "v_boundary_res[0] = v_old[0]\n", @@ -154,15 +138,14 @@ "p_boundary_tur[0] = p_old[-1]\n", "\n", "LA_soll_vec = np.full_like(t_vec,T1.LA)\n", - "Pegelregler.control_variable = T1.LA\n", - "\n", + "LA_ist_vec = np.full_like(t_vec,T1.LA)\n", "\n", "\n" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -178,16 +161,11 @@ "axs1[0].set_ylabel(r'$p$ ['+conversion_pressure_unit+']')\n", "axs1[1].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", "axs1[1].set_ylabel(r'$v$ [$\\mathrm{m} / \\mathrm{s}$]')\n", - "lo_00, = axs1[0].plot(pl_vec,pressure_conversion(pipe.p_old,initial_pressure_unit, conversion_pressure_unit)[0],marker='.')\n", - "lo_01, = axs1[1].plot(pl_vec,pipe.v_old,marker='.')\n", + "lo_00, = axs1[0].plot(pl_vec,pressure_conversion(p_old,initial_pressure_unit, conversion_pressure_unit),marker='.')\n", + "lo_01, = axs1[1].plot(pl_vec,v_old,marker='.')\n", "axs1[0].autoscale()\n", - "axs1[1].set_ylim([0,2])\n", - "# displaying the reservoir level within each pipeline timestep\n", - "# axs1[2].set_title('Level reservoir')\n", - "# axs1[2].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", - "# axs1[2].set_ylabel(r'$h$ [m]')\n", - "# lo_02, = axs1[2].plot(level_vec_2)\n", - "# axs1[2].autoscale()\n", + "axs1[1].autoscale()\n", + "\n", "fig1.tight_layout()\n", "fig1.show()\n", "plt.pause(1)\n" @@ -195,65 +173,83 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2146505196687856\n" + ] + } + ], + "source": [ + "print(initial_flux/area_outflux)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# loop through time steps of the pipeline\n", "for it_pipe in range(1,pipe.nt+1):\n", "\n", - " if it_pipe == 150:\n", - " V.influx = 0\n", "\n", + " if it_pipe > 0.015*(nt+1):\n", + " if V.get_current_influx() > 0:\n", + " V.set_influx(np.max([V.get_current_influx()-initial_flux*5*1e-3,0.]))\n", "# for each pipeline timestep, execute nt_eRK4 timesteps of the reservoir code\n", " # set initial conditions for the reservoir time evolution calculted with e-RK4\n", - " V.pressure = p_old[0]\n", - " V.outflux_vel = v_old[0]\n", + " V.set_pressure = p_old[0]\n", + " V.set_outflux = v_old[0]\n", " # calculate the time evolution of the reservoir level within each pipeline timestep to avoid runaway numerical error\n", " for it_res in range(nt_eRK4):\n", - " V.e_RK_4() # call e-RK4 to update outflux\n", - " V.level = V.update_level(V.timestep) # \n", - " V.set_volume() # update volume in reservoir\n", - " level_vec_2[it_res] = V.level # save for plotting\n", - " if (V.level < critical_level_low) or (V.level > critical_level_high): # make sure to never exceed critical levels\n", - " i_max = it_pipe # for plotting only calculated values\n", - " break \n", - " level_vec[it_pipe] = V.level \n", + " V.timestep_reservoir_evolution() \n", + " level_vec[it_pipe] = V.get_current_level() \n", + "\n", + " # get the control variable\n", + " Pegelregler.update_control_variable(level_vec[it_pipe])\n", + " LA_soll_vec[it_pipe] = Pegelregler.get_current_control_variable()\n", + " \n", + " # change the Leitapparatöffnung based on the target value\n", + " T1.update_LA(LA_soll_vec[it_pipe])\n", + " T1.set_pressure(p_old[-1])\n", + "\n", + " LA_ist_vec[it_pipe] = T1.LA\n", "\n", " # set boundary conditions for the next timestep of the characteristic method\n", - " p_boundary_res[it_pipe] = rho*g*V.level-V.outflux_vel**2*rho/2\n", - " v_boundary_res[it_pipe] = v_old[1]+1/(rho*c)*(p_boundary_res[it_pipe]-p_old[1])-f_D*dt/(2*D)*abs(v_old[1])*v_old[1] \\\n", - " +dt*g*np.sin(alpha)\n", - "\n", - " LA_soll_vec[it_pipe] = Pegelregler.get_control_variable(V.level)\n", - " T1.change_LA(LA_soll_vec[it_pipe],dt)\n", - " v_boundary_tur[it_pipe] = 1/A_pipe*T1.get_Q(p_old[-1])\n", + " p_boundary_res[it_pipe] = V.get_current_pressure()\n", + " v_boundary_tur[it_pipe] = 1/A_pipe*T1.get_current_Q()\n", "\n", " # the the boundary conditions in the pipe.object and thereby calculate boundary pressure at turbine\n", - " pipe.set_boundary_conditions_next_timestep(v_boundary_res[it_pipe],p_boundary_res[it_pipe],v_boundary_tur[it_pipe])\n", - " p_boundary_tur[it_pipe] = pipe.p_boundary_tur\n", + " pipe.set_boundary_conditions_next_timestep(p_boundary_res[it_pipe],v_boundary_tur[it_pipe])\n", + " p_boundary_tur[it_pipe] = pipe.get_current_pressure_distribution()[-1]\n", + " v_boundary_res[it_pipe] = pipe.get_current_velocity_distribution()[0]\n", "\n", " # perform the next timestep via the characteristic method\n", " pipe.timestep_characteristic_method()\n", "\n", + " # prepare for next loop\n", + " p_old = pipe.get_current_pressure_distribution()\n", + " v_old = pipe.get_current_velocity_distribution()\n", + "\n", " # plot some stuff\n", " # remove line-objects to autoscale axes (there is definetly a better way, but this works ¯\\_(ツ)_/¯ )\n", " lo_00.remove()\n", " lo_01.remove()\n", " # lo_02.remove()\n", " # plot new pressure and velocity distribution in the pipeline\n", - " lo_00, = axs1[0].plot(pl_vec,pressure_conversion(pipe.p_old,initial_pressure_unit, conversion_pressure_unit)[0],marker='.',c='blue')\n", - " lo_01, = axs1[1].plot(pl_vec,pipe.v_old,marker='.',c='blue')\n", + " lo_00, = axs1[0].plot(pl_vec,pressure_conversion(p_old,initial_pressure_unit, conversion_pressure_unit),marker='.',c='blue')\n", + " lo_01, = axs1[1].plot(pl_vec,v_old,marker='.',c='blue')\n", " # lo_02, = axs1[2].plot(level_vec_2,c='blue')\n", " fig1.suptitle(str(round(t_vec[it_pipe],2))+ ' s / '+str(round(t_vec[-1],2)) + ' s' )\n", " fig1.canvas.draw()\n", " fig1.tight_layout()\n", " fig1.show()\n", - " plt.pause(0.1) \n", - "\n", - " # prepare for next loop\n", - " p_old = pipe.p_old\n", - " v_old = pipe.v_old \n", + " plt.pause(0.001) \n", "\n", " \n", " " @@ -261,37 +257,64 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "# plot time evolution of boundary pressure and velocity as well as the reservoir level\n", "\n", "fig2,axs2 = plt.subplots(3,2)\n", - "axs2[0,0].plot(t_vec,pressure_conversion(p_boundary_res,initial_pressure_unit, conversion_pressure_unit)[0])\n", - "axs2[0,1].plot(t_vec,v_boundary_res)\n", - "axs2[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,initial_pressure_unit, conversion_pressure_unit)[0])\n", - "axs2[1,1].plot(t_vec,v_boundary_tur)\n", - "axs2[2,0].plot(t_vec,level_vec)\n", "axs2[0,0].set_title('Pressure reservoir')\n", - "axs2[0,1].set_title('Velocity reservoir')\n", - "axs2[1,0].set_title('Pressure turbine')\n", - "axs2[1,1].set_title('Velocity turbine')\n", - "axs2[2,0].set_title('Level reservoir')\n", + "axs2[0,0].plot(t_vec,pressure_conversion(p_boundary_res,initial_pressure_unit, conversion_pressure_unit))\n", "axs2[0,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs2[0,0].set_ylabel(r'$p$ ['+conversion_pressure_unit+']')\n", + "\n", + "axs2[0,1].set_title('Velocity reservoir')\n", + "axs2[0,1].plot(t_vec,v_boundary_res)\n", + "axs2[0,1].set_ylim(-2*Q_nenn,+2*Q_nenn)\n", "axs2[0,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs2[0,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "\n", + "axs2[1,0].set_title('Pressure turbine')\n", + "axs2[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,initial_pressure_unit, conversion_pressure_unit))\n", "axs2[1,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs2[1,0].set_ylabel(r'$p$ ['+conversion_pressure_unit+']')\n", + "\n", + "axs2[1,1].set_title('Velocity turbine')\n", + "axs2[1,1].plot(t_vec,v_boundary_tur)\n", "axs2[1,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs2[1,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "\n", + "axs2[2,0].set_title('Level reservoir')\n", + "axs2[2,0].plot(t_vec,level_vec)\n", "axs2[2,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", "axs2[2,0].set_ylabel(r'$h$ [m]')\n", - "axs2[2,1].axis('off')\n", + "\n", + "axs2[2,1].set_title('LA')\n", + "axs2[2,1].plot(t_vec,100*LA_soll_vec)\n", + "axs2[2,1].plot(t_vec,100*LA_ist_vec)\n", + "axs2[2,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[2,1].set_ylabel(r'$LA$ [%]')\n", "fig2.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n" + ] + } + ], + "source": [ + "print(np.sum(v_boundary_res[2500:])*area_outflux)" + ] } ], "metadata": { From 176fa556ffbc4bfe09f080fcf1c6b45544f63af8 Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Wed, 27 Jul 2022 15:11:31 +0200 Subject: [PATCH 04/11] added dynamic pressure effect to the FODE function --- Ausgleichsbecken/Ausgleichsbecken_class_file.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Ausgleichsbecken/Ausgleichsbecken_class_file.py b/Ausgleichsbecken/Ausgleichsbecken_class_file.py index 937e082..18350e9 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken/Ausgleichsbecken_class_file.py @@ -21,7 +21,7 @@ def FODE_function(x,h,A,A_a,p,rho,g): # A ... Reservoir_Area # g ... gravitational acceleration # rho ... density of the liquid in the reservoir - f = x*abs(x)/h*(A_a/A-1)+g-p/(rho*h) + f = x*abs(x)/h*(A_a/A-1.5)+g-p/(rho*h) return f From 03ff67e0ad8baf586e694bab1fc65823fed25f30 Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Wed, 27 Jul 2022 16:02:39 +0200 Subject: [PATCH 05/11] working on a fix for steady state Ausgleichsbecken --- .../Ausgleichsbecken_class_file.py | 2 +- .../Ausgleichsbecken_test_steady_state.ipynb | 97 +++++++++++++++---- .../Druckrohrleitung_class_file.py | 24 ++--- .../Druckrohrleitung_test_steady_state.ipynb | 44 ++++++--- 4 files changed, 121 insertions(+), 46 deletions(-) diff --git a/Ausgleichsbecken/Ausgleichsbecken_class_file.py b/Ausgleichsbecken/Ausgleichsbecken_class_file.py index 18350e9..e7f7264 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken/Ausgleichsbecken_class_file.py @@ -21,7 +21,7 @@ def FODE_function(x,h,A,A_a,p,rho,g): # A ... Reservoir_Area # g ... gravitational acceleration # rho ... density of the liquid in the reservoir - f = x*abs(x)/h*(A_a/A-1.5)+g-p/(rho*h) + f = x*abs(x)/h*(A_a/A-1.)+g-p/(rho*h) return f diff --git a/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb b/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb index 1b82115..6d6c071 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb +++ b/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -21,32 +21,64 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ + "L = 1000.\n", + "n = 10000 # number of pipe segments in discretization\n", + "c = 400. \n", + "dx = L/n # length of each pipe segment\n", + "dt = dx/c \n", + "\n", "# define constants\n", - "initial_level = 10. # m\n", - "initial_influx = 5. # m³/s\n", - "# initial_outflux = 1. # m³/s\n", - "# initial_pipeline_pressure = 10.\n", - "# initial_pressure_unit = 'mWS'\n", + "initial_level = 10.1 # m\n", + "initial_influx = 0.8 # m³/s\n", "conversion_pressure_unit = 'mWS'\n", "\n", - "area_base = 1. # m²\n", - "area_outflux = 0.5 # m²\n", + "area_base = 75. # m²\n", + "area_outflux = (0.9/2)**2*np.pi # m²\n", "critical_level_low = 0. # m\n", "critical_level_high = 10. # m\n", - "simulation_timestep = 0.001 # s\n", + "simulation_timestep = dt # s\n", "\n", "# for while loop\n", "total_min_level = 0.01 # m\n", - "total_max_time = 1000 # s" + "total_max_time = 1000 # s\n", + "\n", + "nt = int(total_max_time//simulation_timestep)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# # define constants\n", + "# initial_level = 10.1 # m\n", + "# initial_influx = 5. # m³/s\n", + "# # initial_outflux = 1. # m³/s\n", + "# # initial_pipeline_pressure = 10.\n", + "# # initial_pressure_unit = 'mWS'\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.0005 # s\n", + "\n", + "# # for while loop\n", + "# total_min_level = 0.01 # m\n", + "# total_max_time = 1000 # s\n", + "\n", + "# nt = int(total_max_time//simulation_timestep)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -60,22 +92,25 @@ "# V.pressure = converted_pressure\n", "V.set_steady_state(initial_influx,initial_level,conversion_pressure_unit)\n", "\n", - "time_vec = np.arange(0,total_max_time,simulation_timestep)\n", - "outflux_vec = np.empty_like(time_vec)\n", + "time_vec = np.arange(0,nt+1,1)*simulation_timestep\n", + "outflux_vec = np.zeros_like(time_vec)\n", "outflux_vec[0] = V.get_current_outflux()\n", - "level_vec = np.empty_like(time_vec)\n", + "level_vec = np.zeros_like(time_vec)\n", "level_vec[0] = V.get_current_level()\n", + "pressure_vec = np.zeros_like(time_vec)\n", + "pressure_vec[0] = V.get_current_pressure()\n", "\n", "# pressure_vec = np.full_like(time_vec,converted_pressure)*((np.sin(time_vec)+1)*np.exp(-time_vec/50))\n", - "pressure_vec = np.full_like(time_vec,V.get_current_pressure())\n", " \n", "i_max = -1\n", "\n", - "for i in range(np.size(time_vec)-1):\n", - " V.set_pressure(pressure_vec[i])\n", + "for i in range(1,nt+1):\n", + " V.set_pressure(pressure_vec[i-1])\n", + " V.set_outflux(outflux_vec[i-1])\n", " V.timestep_reservoir_evolution()\n", - " outflux_vec[i+1] = V.get_current_outflux()\n", - " level_vec[i+1] = V.get_current_level()\n", + " outflux_vec[i] = V.get_current_outflux()\n", + " level_vec[i] = V.get_current_level()\n", + " pressure_vec[i] = V.get_current_pressure()\n", " if V.level < total_min_level:\n", " i_max = i\n", " break\n", @@ -84,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -111,6 +146,26 @@ "\n", "fig1.tight_layout() " ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19.987523898552976" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "V.get_current_level()" + ] } ], "metadata": { diff --git a/Druckrohrleitung/Druckrohrleitung_class_file.py b/Druckrohrleitung/Druckrohrleitung_class_file.py index 71d553b..7cf4c12 100644 --- a/Druckrohrleitung/Druckrohrleitung_class_file.py +++ b/Druckrohrleitung/Druckrohrleitung_class_file.py @@ -88,17 +88,17 @@ class Druckrohrleitung_class: # the velocity at the reservoir will be calculated using the backward characteristic # constants for a cleaner formula - rho = self.density - c = self.c - f_D = self.f_D - dt = self.dt - D = self.dia - g = self.g - alpha = self.angle - p_old_tur = self.p_old[-2] # @ second to last node (the one before the turbine) - v_old_tur = self.v_old[-2] # @ second to last node (the one before the turbine) - p_old_res = self.p_old[1] # @ second node (the one after the reservoir) - v_old_res = self.v_old[1] # @ second node (the one after the reservoir) + rho = self.density + c = self.c + f_D = self.f_D + dt = self.dt + D = self.dia + g = self.g + alpha = self.angle + p_old_tur = self.p_old[-2] # @ second to last node (the one before the turbine) + v_old_tur = self.v_old[-2] # @ second to last node (the one before the turbine) + p_old_res = self.p_old[1] # @ second node (the one after the reservoir) + v_old_res = self.v_old[1] # @ second node (the one after the reservoir) # set the boundary conditions derived from reservoir and turbine v_boundary_tur = v_turbine # at new timestep p_boundary_res = p_reservoir # at new timestep @@ -117,7 +117,7 @@ class Druckrohrleitung_class: # the flow velocity is given by the constant flow through the pipe ss_v0 = np.full(self.n_seg+1,ss_flux/self.A) # the static pressure is given by the hydrostatic pressure, corrected for friction losses and dynamic pressure - ss_pressure = (self.density*self.g*(ss_level_reservoir+h_vec)-ss_v0**2*self.density/2)-(self.f_D*pl_vec/self.dia*self.density/2*ss_v0**2) + ss_pressure = self.density*self.g*(ss_level_reservoir+h_vec)-ss_v0**2*self.density/2-(self.f_D*pl_vec/self.dia*self.density/2*ss_v0**2) self.set_initial_flow_velocity(ss_v0) self.set_initial_pressure(ss_pressure) diff --git a/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb b/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb index e92c8b6..ff4719f 100644 --- a/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb +++ b/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb @@ -35,8 +35,8 @@ "L = 1000. # length of pipeline [m]\n", "D = 0.9 # pipe diameter [m]\n", "h_res = 10. # water level in upstream reservoir [m]\n", - "n = 50 # number of pipe segments in discretization\n", - "nt = 5000 # number of time steps after initial conditions\n", + "n = 50000 # number of pipe segments in discretization\n", + "nt = 12 # number of time steps after initial conditions\n", "f_D = 0.01 # Darcy friction factor\n", "c = 400. # propagation velocity of the pressure wave [m/s]\n", "h_pipe = 105. # hydraulic head without reservoir [m] \n", @@ -49,9 +49,9 @@ "dx = L/n # length of each pipe segment\n", "dt = dx/c # timestep according to method of characterisitics\n", "nn = n+1 # number of nodes\n", - "pl_vec = np.arange(0,nn*dx,dx) # pl = pipe-length. position of the nodes on the pipeline\n", - "t_vec = np.arange(0,nt*dt,dt) # time vector\n", - "h_vec = np.arange(0,h_pipe+h_pipe/n,h_pipe/n) # hydraulic head of pipeline at each node\n", + "pl_vec = np.arange(0,nn,1)*dx # pl = pipe-length. position of the nodes on the pipeline\n", + "t_vec = np.arange(0,nt,1)*dt # time vector\n", + "h_vec = np.arange(0,nn,1)*h_pipe/n # hydraulic head of pipeline at each node\n", "\n", "\n", "# define constants reservoir\n", @@ -91,6 +91,7 @@ "print(V.get_current_influx())\n", "print(V.get_current_outflux())\n", "print(V.get_current_level())\n", + "print(rho*g*V.get_current_level()-rho/2*(V.get_current_outflux()/area_pipe)**2)\n", "print(V.get_current_pressure())\n", "print(pipe.get_current_pressure_distribution()[0])\n", "print(pipe.get_current_velocity_distribution()*area_pipe)\n", @@ -99,7 +100,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -130,7 +131,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -153,16 +154,33 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 22, "metadata": {}, - "outputs": [], + "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;32my:\\KELAG\\KS\\KS-PW\\04 Digitalisierung\\KSPWDEV Server\\Digital Trainee Projekt\\DT_Slot_3_Project_Repo\\Druckrohrleitung\\Druckrohrleitung_test_steady_state.ipynb Cell 7\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 40\u001b[0m fig1\u001b[39m.\u001b[39mcanvas\u001b[39m.\u001b[39mdraw()\n\u001b[0;32m 41\u001b[0m fig1\u001b[39m.\u001b[39mtight_layout()\n\u001b[1;32m---> 42\u001b[0m plt\u001b[39m.\u001b[39;49mpause(\u001b[39m0.000001\u001b[39;49m)\n", + "File \u001b[1;32mc:\\ProgramData\\Anaconda3\\envs\\Georg_DT_Slot3\\lib\\site-packages\\matplotlib\\pyplot.py:548\u001b[0m, in \u001b[0;36mpause\u001b[1;34m(interval)\u001b[0m\n\u001b[0;32m 546\u001b[0m canvas\u001b[39m.\u001b[39mdraw_idle()\n\u001b[0;32m 547\u001b[0m show(block\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m--> 548\u001b[0m canvas\u001b[39m.\u001b[39;49mstart_event_loop(interval)\n\u001b[0;32m 549\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 550\u001b[0m time\u001b[39m.\u001b[39msleep(interval)\n", + "File \u001b[1;32mc:\\ProgramData\\Anaconda3\\envs\\Georg_DT_Slot3\\lib\\site-packages\\matplotlib\\backends\\backend_qt.py:409\u001b[0m, in \u001b[0;36mFigureCanvasQT.start_event_loop\u001b[1;34m(self, timeout)\u001b[0m\n\u001b[0;32m 405\u001b[0m timer \u001b[39m=\u001b[39m QtCore\u001b[39m.\u001b[39mQTimer\u001b[39m.\u001b[39msingleShot(\u001b[39mint\u001b[39m(timeout \u001b[39m*\u001b[39m \u001b[39m1000\u001b[39m),\n\u001b[0;32m 406\u001b[0m event_loop\u001b[39m.\u001b[39mquit)\n\u001b[0;32m 408\u001b[0m \u001b[39mwith\u001b[39;00m _maybe_allow_interrupt(event_loop):\n\u001b[1;32m--> 409\u001b[0m qt_compat\u001b[39m.\u001b[39m_exec(event_loop)\n", + "File \u001b[1;32mc:\\ProgramData\\Anaconda3\\envs\\Georg_DT_Slot3\\lib\\contextlib.py:120\u001b[0m, in \u001b[0;36m_GeneratorContextManager.__exit__\u001b[1;34m(self, type, value, traceback)\u001b[0m\n\u001b[0;32m 118\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mtype\u001b[39m \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 119\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m--> 120\u001b[0m \u001b[39mnext\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mgen)\n\u001b[0;32m 121\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mStopIteration\u001b[39;00m:\n\u001b[0;32m 122\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mFalse\u001b[39;00m\n", + "File \u001b[1;32mc:\\ProgramData\\Anaconda3\\envs\\Georg_DT_Slot3\\lib\\site-packages\\matplotlib\\backends\\qt_compat.py:262\u001b[0m, in \u001b[0;36m_maybe_allow_interrupt\u001b[1;34m(qapp)\u001b[0m\n\u001b[0;32m 260\u001b[0m signal\u001b[39m.\u001b[39msignal(signal\u001b[39m.\u001b[39mSIGINT, old_sigint_handler)\n\u001b[0;32m 261\u001b[0m \u001b[39mif\u001b[39;00m handler_args \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m--> 262\u001b[0m old_sigint_handler(\u001b[39m*\u001b[39;49mhandler_args)\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], "source": [ "\n", "for it_pipe in range(1,nt):\n", "# for each pipeline timestep, execute nt_eRK4 timesteps of the reservoir code\n", " # set initial conditions for the reservoir time evolution calculted with e-RK4\n", " V.set_pressure = p_old[0]\n", - " V.set_outflux = v_old[0]*area_pipe\n", + " # V.set_outflux = v_old[0]*area_pipe\n", + " print(V.get_current_pressure())\n", " # calculate the time evolution of the reservoir level within each pipeline timestep to avoid runaway numerical error\n", " for it_res in range(nt_eRK4):\n", " V.timestep_reservoir_evolution() \n", @@ -171,6 +189,7 @@ " \n", " # set boundary conditions for the next timestep of the characteristic method\n", " p_boundary_res[it_pipe] = V.get_current_pressure()\n", + " print(V.get_current_pressure())\n", " v_boundary_tur[it_pipe] = initial_flux/area_pipe\n", "\n", " # the the boundary conditions in the pipe.object and thereby calculate boundary pressure at turbine\n", @@ -194,10 +213,11 @@ " lo_00, = axs1[0].plot(pl_vec,pressure_conversion(p_old,'Pa', conversion_pressure_unit),marker='.',c='blue')\n", " lo_01, = axs1[1].plot(pl_vec,v_old,marker='.',c='blue')\n", " \n", - " fig1.suptitle(str(round(t_vec[it_pipe],2)) + '/' + str(t_vec[-1]))\n", + " fig1.suptitle(str(round(t_vec[it_pipe],2)) + '/' + str(round(t_vec[-1],2)))\n", " fig1.canvas.draw()\n", " fig1.tight_layout()\n", - " plt.pause(0.00001)\n" + " plt.pause(0.000001)\n", + "\n" ] }, { From 9df448663ef3ca3eefadf11d0b089ff78fb35701 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Georg=20=C2=B4Brantegger?= Date: Thu, 28 Jul 2022 11:36:39 +0200 Subject: [PATCH 06/11] corrected steady state pressure to work properly --- .../Ausgleichsbecken_class_file.py | 17 ++-- .../Ausgleichsbecken_test_steady_state.ipynb | 82 +++++++++---------- 2 files changed, 52 insertions(+), 47 deletions(-) diff --git a/Ausgleichsbecken/Ausgleichsbecken_class_file.py b/Ausgleichsbecken/Ausgleichsbecken_class_file.py index e7f7264..fc65ea1 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken/Ausgleichsbecken_class_file.py @@ -9,19 +9,19 @@ parent = os.path.dirname(current) sys.path.append(parent) from functions.pressure_conversion import pressure_conversion -def FODE_function(x,h,A,A_a,p,rho,g): +def FODE_function(x_out,h,A,A_a,p,rho,g): # (FODE ... first order differential equation) # based on the outflux formula by Andreas Malcherek # https://www.youtube.com/watch?v=8HO2LwqOhqQ # adapted for a pressurized pipeline into which the reservoir effuses # and flow direction - # x ... effusion velocity + # x_out ... effusion velocity # h ... level in the reservoir # A_a ... Outflux_Area # A ... Reservoir_Area # g ... gravitational acceleration # rho ... density of the liquid in the reservoir - f = x*abs(x)/h*(A_a/A-1.)+g-p/(rho*h) + f = x_out*abs(x_out)/h*(A_a/A-1.)+g-p/(rho*h) return f @@ -101,8 +101,10 @@ class Ausgleichsbecken_class: def set_steady_state(self,ss_influx,ss_level,display_pressure_unit): # set the steady state (ss) condition in which the net flux is zero # set pressure acting on the outflux area so that the level stays constant - ss_outflux = ss_influx - ss_pressure = self.density*self.g*ss_level-(ss_outflux/self.area_outflux)**2*self.density/2 + ss_outflux = ss_influx + ss_influx_vel = ss_influx/self.area + ss_outflux_vel = ss_outflux/self.area_outflux + ss_pressure = self.density*self.g*ss_level+self.density*ss_outflux_vel*(ss_influx_vel-ss_outflux_vel) self.set_influx(ss_influx) self.set_initial_level(ss_level) @@ -181,7 +183,10 @@ class Ausgleichsbecken_class: return self.level*self.area def update_pressure(self): - p_new = self.density*self.g*self.level-(self.outflux/self.area_outflux)**2*self.density/2 + influx_vel = self.influx/self.area + outflux_vel = self.outflux/self.area_outflux + p_new = self.density*self.g*self.level+self.density*outflux_vel*(influx_vel-outflux_vel) + return p_new def timestep_reservoir_evolution(self): diff --git a/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb b/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb index 6d6c071..05239aa 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb +++ b/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -31,54 +31,54 @@ "dx = L/n # length of each pipe segment\n", "dt = dx/c \n", "\n", - "# define constants\n", - "initial_level = 10.1 # m\n", - "initial_influx = 0.8 # m³/s\n", - "conversion_pressure_unit = 'mWS'\n", - "\n", - "area_base = 75. # m²\n", - "area_outflux = (0.9/2)**2*np.pi # m²\n", - "critical_level_low = 0. # m\n", - "critical_level_high = 10. # m\n", - "simulation_timestep = dt # s\n", - "\n", - "# for while loop\n", - "total_min_level = 0.01 # m\n", - "total_max_time = 1000 # s\n", - "\n", - "nt = int(total_max_time//simulation_timestep)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ "# # define constants\n", "# initial_level = 10.1 # m\n", - "# initial_influx = 5. # m³/s\n", - "# # initial_outflux = 1. # m³/s\n", - "# # initial_pipeline_pressure = 10.\n", - "# # initial_pressure_unit = 'mWS'\n", + "# initial_influx = 0.8 # m³/s\n", "# conversion_pressure_unit = 'mWS'\n", "\n", - "# area_base = 1. # m²\n", - "# area_outflux = 0.5 # m²\n", + "# area_base = 75. # m²\n", + "# area_outflux = (0.9/2)**2*np.pi # m²\n", "# critical_level_low = 0. # m\n", "# critical_level_high = 10. # m\n", - "# simulation_timestep = 0.0005 # s\n", + "# simulation_timestep = dt # s\n", "\n", "# # for while loop\n", "# total_min_level = 0.01 # m\n", - "# total_max_time = 1000 # s\n", + "# total_max_time = 100 # s\n", "\n", "# nt = int(total_max_time//simulation_timestep)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# define constants\n", + "initial_level = 10.1 # m\n", + "initial_influx = 1. # m³/s\n", + "# initial_outflux = 1. # m³/s\n", + "# initial_pipeline_pressure = 10.\n", + "# initial_pressure_unit = 'mWS'\n", + "conversion_pressure_unit = 'mWS'\n", + "\n", + "area_base = 75. # m²\n", + "area_outflux = 2. # m²\n", + "critical_level_low = 0. # m\n", + "critical_level_high = 10. # m\n", + "simulation_timestep = dt # s\n", + "\n", + "# for while loop\n", + "total_min_level = 0.01 # m\n", + "total_max_time = 1 # s\n", + "\n", + "nt = int(total_max_time//simulation_timestep)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -149,16 +149,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "19.987523898552976" + "10.1" ] }, - "execution_count": 12, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -170,7 +170,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", + "display_name": "Python 3.8.13 ('DT_Slot_3')", "language": "python", "name": "python3" }, @@ -189,7 +189,7 @@ "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" + "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" } } }, From e90406d90b254dfd87d0c6c79e6aa078063f88e7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Georg=20=C2=B4Brantegger?= Date: Thu, 28 Jul 2022 12:23:45 +0200 Subject: [PATCH 07/11] corrected the steady state method to work properly --- .../Druckrohrleitung_class_file.py | 10 +- .../Druckrohrleitung_test_steady_state.ipynb | 2060 ++++++++++++++++- 2 files changed, 2038 insertions(+), 32 deletions(-) diff --git a/Druckrohrleitung/Druckrohrleitung_class_file.py b/Druckrohrleitung/Druckrohrleitung_class_file.py index 7cf4c12..44e759d 100644 --- a/Druckrohrleitung/Druckrohrleitung_class_file.py +++ b/Druckrohrleitung/Druckrohrleitung_class_file.py @@ -112,12 +112,16 @@ class Druckrohrleitung_class: self.p[0] = p_boundary_res self.p[-1] = p_boundary_tur - def set_steady_state(self,ss_flux,ss_level_reservoir,pl_vec,h_vec): + def set_steady_state(self,ss_flux,ss_level_reservoir,area_reservoir,pl_vec,h_vec): # set the pressure and velocity distributions, that allow a constant flow of water from the (steady-state) reservoir to the (steady-state) turbine # the flow velocity is given by the constant flow through the pipe ss_v0 = np.full(self.n_seg+1,ss_flux/self.A) - # the static pressure is given by the hydrostatic pressure, corrected for friction losses and dynamic pressure - ss_pressure = self.density*self.g*(ss_level_reservoir+h_vec)-ss_v0**2*self.density/2-(self.f_D*pl_vec/self.dia*self.density/2*ss_v0**2) + + # the static pressure is given by static state pressure of the reservoir, corrected for the hydraulic head of the pipe and friction losses + ss_v_in_res = ss_flux/area_reservoir + ss_v_out_res = ss_flux/self.A + ss_pressure_res = self.density*self.g*(ss_level_reservoir)+self.density*ss_v_out_res*(ss_v_in_res-ss_v_out_res) + ss_pressure = ss_pressure_res+(self.density*self.g*h_vec)-(self.f_D*pl_vec/self.dia*self.density/2*ss_v0**2) self.set_initial_flow_velocity(ss_v0) self.set_initial_pressure(ss_pressure) diff --git a/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb b/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb index ff4719f..299c49b 100644 --- a/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb +++ b/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -35,8 +35,8 @@ "L = 1000. # length of pipeline [m]\n", "D = 0.9 # pipe diameter [m]\n", "h_res = 10. # water level in upstream reservoir [m]\n", - "n = 50000 # number of pipe segments in discretization\n", - "nt = 12 # number of time steps after initial conditions\n", + "n = 50 # number of pipe segments in discretization\n", + "nt = 1000 # number of time steps after initial conditions\n", "f_D = 0.01 # Darcy friction factor\n", "c = 400. # propagation velocity of the pressure wave [m/s]\n", "h_pipe = 105. # hydraulic head without reservoir [m] \n", @@ -69,24 +69,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "V = Ausgleichsbecken_class(area_base, area_pipe, critical_level_low, critical_level_high,simulation_timestep)\n", + "V = Ausgleichsbecken_class(area_base,area_pipe,critical_level_low,critical_level_high,simulation_timestep)\n", "V.set_steady_state(initial_flux,initial_level,conversion_pressure_unit)\n", "\n", "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", "pipe.set_pressure_propagation_velocity(c)\n", "pipe.set_number_of_timesteps(nt)\n", - "pipe.set_steady_state(initial_flux,initial_level,pl_vec,h_vec)" + "pipe.set_steady_state(initial_flux,initial_level,area_base,pl_vec,h_vec)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8\n", + "0.8\n", + "10.0\n", + "97309.32104824147\n", + "96532.05564888839\n", + "96532.05564888839\n", + "[0.8 0.8 0.8 ... 0.8 0.8 0.8]\n", + "[1.25752054 1.25752054 1.25752054 ... 1.25752054 1.25752054 1.25752054]\n" + ] + } + ], "source": [ "print(V.get_current_influx())\n", "print(V.get_current_outflux())\n", @@ -100,7 +115,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -131,7 +146,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -154,22 +169,2011 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 15, "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;32my:\\KELAG\\KS\\KS-PW\\04 Digitalisierung\\KSPWDEV Server\\Digital Trainee Projekt\\DT_Slot_3_Project_Repo\\Druckrohrleitung\\Druckrohrleitung_test_steady_state.ipynb Cell 7\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 40\u001b[0m fig1\u001b[39m.\u001b[39mcanvas\u001b[39m.\u001b[39mdraw()\n\u001b[0;32m 41\u001b[0m fig1\u001b[39m.\u001b[39mtight_layout()\n\u001b[1;32m---> 42\u001b[0m plt\u001b[39m.\u001b[39;49mpause(\u001b[39m0.000001\u001b[39;49m)\n", - "File \u001b[1;32mc:\\ProgramData\\Anaconda3\\envs\\Georg_DT_Slot3\\lib\\site-packages\\matplotlib\\pyplot.py:548\u001b[0m, in \u001b[0;36mpause\u001b[1;34m(interval)\u001b[0m\n\u001b[0;32m 546\u001b[0m canvas\u001b[39m.\u001b[39mdraw_idle()\n\u001b[0;32m 547\u001b[0m show(block\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m--> 548\u001b[0m canvas\u001b[39m.\u001b[39;49mstart_event_loop(interval)\n\u001b[0;32m 549\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 550\u001b[0m time\u001b[39m.\u001b[39msleep(interval)\n", - "File \u001b[1;32mc:\\ProgramData\\Anaconda3\\envs\\Georg_DT_Slot3\\lib\\site-packages\\matplotlib\\backends\\backend_qt.py:409\u001b[0m, in \u001b[0;36mFigureCanvasQT.start_event_loop\u001b[1;34m(self, timeout)\u001b[0m\n\u001b[0;32m 405\u001b[0m timer \u001b[39m=\u001b[39m QtCore\u001b[39m.\u001b[39mQTimer\u001b[39m.\u001b[39msingleShot(\u001b[39mint\u001b[39m(timeout \u001b[39m*\u001b[39m \u001b[39m1000\u001b[39m),\n\u001b[0;32m 406\u001b[0m event_loop\u001b[39m.\u001b[39mquit)\n\u001b[0;32m 408\u001b[0m \u001b[39mwith\u001b[39;00m _maybe_allow_interrupt(event_loop):\n\u001b[1;32m--> 409\u001b[0m qt_compat\u001b[39m.\u001b[39m_exec(event_loop)\n", - "File \u001b[1;32mc:\\ProgramData\\Anaconda3\\envs\\Georg_DT_Slot3\\lib\\contextlib.py:120\u001b[0m, in \u001b[0;36m_GeneratorContextManager.__exit__\u001b[1;34m(self, type, value, traceback)\u001b[0m\n\u001b[0;32m 118\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mtype\u001b[39m \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 119\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m--> 120\u001b[0m \u001b[39mnext\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mgen)\n\u001b[0;32m 121\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mStopIteration\u001b[39;00m:\n\u001b[0;32m 122\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mFalse\u001b[39;00m\n", - "File \u001b[1;32mc:\\ProgramData\\Anaconda3\\envs\\Georg_DT_Slot3\\lib\\site-packages\\matplotlib\\backends\\qt_compat.py:262\u001b[0m, in \u001b[0;36m_maybe_allow_interrupt\u001b[1;34m(qapp)\u001b[0m\n\u001b[0;32m 260\u001b[0m signal\u001b[39m.\u001b[39msignal(signal\u001b[39m.\u001b[39mSIGINT, old_sigint_handler)\n\u001b[0;32m 261\u001b[0m \u001b[39mif\u001b[39;00m handler_args \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m--> 262\u001b[0m old_sigint_handler(\u001b[39m*\u001b[39;49mhandler_args)\n", - "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + "name": "stdout", + "output_type": "stream", + "text": [ + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n", + "96532.05564888839\n" ] } ], @@ -180,7 +2184,6 @@ " # set initial conditions for the reservoir time evolution calculted with e-RK4\n", " V.set_pressure = p_old[0]\n", " # V.set_outflux = v_old[0]*area_pipe\n", - " print(V.get_current_pressure())\n", " # calculate the time evolution of the reservoir level within each pipeline timestep to avoid runaway numerical error\n", " for it_res in range(nt_eRK4):\n", " V.timestep_reservoir_evolution() \n", @@ -189,7 +2192,6 @@ " \n", " # set boundary conditions for the next timestep of the characteristic method\n", " p_boundary_res[it_pipe] = V.get_current_pressure()\n", - " print(V.get_current_pressure())\n", " v_boundary_tur[it_pipe] = initial_flux/area_pipe\n", "\n", " # the the boundary conditions in the pipe.object and thereby calculate boundary pressure at turbine\n", @@ -222,7 +2224,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -258,7 +2260,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", + "display_name": "Python 3.8.13 ('DT_Slot_3')", "language": "python", "name": "python3" }, @@ -277,7 +2279,7 @@ "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" + "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" } } }, From dc5bcfe7f89195fb7bc0efa0fac38425c57b5202 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Georg=20=C2=B4Brantegger?= Date: Thu, 28 Jul 2022 16:26:04 +0200 Subject: [PATCH 08/11] fixed a coding mistake that lead to a missbehavior in the time evolution of the reservoir --- .../Ausgleichsbecken_class_file.py | 46 +- .../Ausgleichsbecken_test_steady_state.ipynb | 18 +- .../Druckrohrleitung_class_file.py | 4 +- .../Druckrohrleitung_test_steady_state.ipynb | 2054 +---------------- Untertweng.ipynb | 100 +- 5 files changed, 135 insertions(+), 2087 deletions(-) diff --git a/Ausgleichsbecken/Ausgleichsbecken_class_file.py b/Ausgleichsbecken/Ausgleichsbecken_class_file.py index fc65ea1..e07c6b7 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken/Ausgleichsbecken_class_file.py @@ -72,11 +72,13 @@ class Ausgleichsbecken_class: def set_initial_level(self,initial_level): # sets the level in the reservoir and should only be called during initialization if self.level == '--': - self.level = initial_level - self.volume = self.update_volume() + self.level = initial_level else: raise Exception('Initial level was already set once. Use the .update_level(self,timestep) method to update level based on net flux.') + def set_level(self,level): + self.level = level + def set_influx(self,influx): # sets influx to the reservoir in m³/s # positive influx means that liquid flows into the reservoir @@ -95,15 +97,14 @@ class Ausgleichsbecken_class: def set_pressure(self,pressure): # sets the static pressure present at the outlet of the reservoir - # units are used to convert and display the pressure - self.pressure = pressure + self.pressure = pressure def set_steady_state(self,ss_influx,ss_level,display_pressure_unit): # set the steady state (ss) condition in which the net flux is zero # set pressure acting on the outflux area so that the level stays constant ss_outflux = ss_influx - ss_influx_vel = ss_influx/self.area - ss_outflux_vel = ss_outflux/self.area_outflux + ss_influx_vel = abs(ss_influx/self.area) + ss_outflux_vel = abs(ss_outflux/self.area_outflux) ss_pressure = self.density*self.g*ss_level+self.density*ss_outflux_vel*(ss_influx_vel-ss_outflux_vel) self.set_influx(ss_influx) @@ -115,6 +116,7 @@ class Ausgleichsbecken_class: def get_info(self, full = False): new_line = '\n' p = pressure_conversion(self.pressure,self.pressure_unit,self.pressure_unit_print) + outflux_vel = self.outflux/self.area_outflux if full == True: @@ -129,7 +131,7 @@ class Ausgleichsbecken_class: f"Volume in reservoir = {self.volume:<10} {self.volume_unit_print} {new_line}" f"Current influx = {self.influx:<10} {self.flux_unit_print} {new_line}" f"Current outflux = {self.outflux:<10} {self.flux_unit_print} {new_line}" - f"Current outflux vel = {round(self.outflux_vel,3):<10} {self.velocity_unit_print} {new_line}" + f"Current outflux vel = {round(outflux_vel,3):<10} {self.velocity_unit_print} {new_line}" f"Current pipe pressure = {round(p,3):<10} {self.pressure_unit_print} {new_line}" f"Simulation timestep = {self.timestep:<10} {self.time_unit_print} {new_line}" f"Density of liquid = {self.density:<10} {self.density_unit_print} {new_line}" @@ -142,7 +144,7 @@ class Ausgleichsbecken_class: f"Volume in reservoir = {self.volume:<10} {self.volume_unit_print} {new_line}" f"Current influx = {self.influx:<10} {self.flux_unit_print} {new_line}" f"Current outflux = {self.outflux:<10} {self.flux_unit_print} {new_line}" - f"Current outflux vel = {round(self.outflux_vel,3):<10} {self.velocity_unit_print} {new_line}" + f"Current outflux vel = {round(outflux_vel,3):<10} {self.velocity_unit_print} {new_line}" f"Current pipe pressure = {round(p,3):<10} {self.pressure_unit_print} {new_line}" f"----------------------------- {new_line}") @@ -157,9 +159,6 @@ class Ausgleichsbecken_class: def get_current_outflux(self): return self.outflux - def get_current_volume(self): - return self.volume - def get_current_pressure(self): return self.pressure @@ -174,19 +173,14 @@ class Ausgleichsbecken_class: # cannot set new level directly in this method, because it gets called to calcuate during the Runge Kutta # to calculate a ficticious level at half the timestep net_flux = self.influx-self.outflux - delta_V = net_flux*timestep - new_level = (self.volume+delta_V)/self.area + delta_level = net_flux*timestep/self.area + new_level = (self.level+delta_level) return new_level - def update_volume(self): - # sets volume in reservoir based on self.level - return self.level*self.area - def update_pressure(self): - influx_vel = self.influx/self.area - outflux_vel = self.outflux/self.area_outflux + influx_vel = abs(self.influx/self.area) + outflux_vel = abs(self.outflux/self.area_outflux) p_new = self.density*self.g*self.level+self.density*outflux_vel*(influx_vel-outflux_vel) - return p_new def timestep_reservoir_evolution(self): @@ -209,8 +203,10 @@ class Ausgleichsbecken_class: ynp1 = yn + dt/6*(FODE_function(Y1,h,A,A_a,p,rho,g)+2*FODE_function(Y2,h_hs,A,A_a,p_hs,rho,g)+ \ 2*FODE_function(Y3,h_hs,A,A_a,p_hs,rho,g)+ FODE_function(Y4,h,A,A_a,p,rho,g)) - self.outflux = ynp1*A_a - self.level = self.update_level(dt) - self.volume = self.update_volume() - self.pressure = self.update_pressure() - + new_outflux = ynp1*A_a + new_level = self.update_level(dt) + new_pressure = self.update_pressure() + + self.set_outflux(new_outflux) + self.set_level(new_level) + self.set_pressure(new_pressure) \ No newline at end of file diff --git a/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb b/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb index 05239aa..5e144d4 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb +++ b/Ausgleichsbecken/Ausgleichsbecken_test_steady_state.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 13, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -71,20 +71,20 @@ "\n", "# for while loop\n", "total_min_level = 0.01 # m\n", - "total_max_time = 1 # s\n", + "total_max_time = 100 # s\n", "\n", "nt = int(total_max_time//simulation_timestep)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "%matplotlib qt\n", "\n", - "V = Ausgleichsbecken_class(area_base, area_outflux, critical_level_low, critical_level_high,simulation_timestep)\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", @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -158,7 +158,7 @@ "10.1" ] }, - "execution_count": 18, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } diff --git a/Druckrohrleitung/Druckrohrleitung_class_file.py b/Druckrohrleitung/Druckrohrleitung_class_file.py index 44e759d..1a0ec3d 100644 --- a/Druckrohrleitung/Druckrohrleitung_class_file.py +++ b/Druckrohrleitung/Druckrohrleitung_class_file.py @@ -118,8 +118,8 @@ class Druckrohrleitung_class: ss_v0 = np.full(self.n_seg+1,ss_flux/self.A) # the static pressure is given by static state pressure of the reservoir, corrected for the hydraulic head of the pipe and friction losses - ss_v_in_res = ss_flux/area_reservoir - ss_v_out_res = ss_flux/self.A + ss_v_in_res = abs(ss_flux/area_reservoir) + ss_v_out_res = abs(ss_flux/self.A) ss_pressure_res = self.density*self.g*(ss_level_reservoir)+self.density*ss_v_out_res*(ss_v_in_res-ss_v_out_res) ss_pressure = ss_pressure_res+(self.density*self.g*h_vec)-(self.f_D*pl_vec/self.dia*self.density/2*ss_v0**2) diff --git a/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb b/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb index 299c49b..fd468bd 100644 --- a/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb +++ b/Druckrohrleitung/Druckrohrleitung_test_steady_state.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 9, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -84,38 +84,33 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.8\n", - "0.8\n", - "10.0\n", - "97309.32104824147\n", - "96532.05564888839\n", - "96532.05564888839\n", - "[0.8 0.8 0.8 ... 0.8 0.8 0.8]\n", - "[1.25752054 1.25752054 1.25752054 ... 1.25752054 1.25752054 1.25752054]\n" + "The current attributes are: \n", + "----------------------------- \n", + "Current level = 10.0 m\n", + "Volume in reservoir = -- m³ \n", + "Current influx = 0.8 m³/s \n", + "Current outflux = 0.8 m³/s \n", + "Current outflux vel = 1.258 m/s \n", + "Current pipe pressure = 9.844 mWS \n", + "----------------------------- \n", + "\n" ] } ], "source": [ - "print(V.get_current_influx())\n", - "print(V.get_current_outflux())\n", - "print(V.get_current_level())\n", - "print(rho*g*V.get_current_level()-rho/2*(V.get_current_outflux()/area_pipe)**2)\n", - "print(V.get_current_pressure())\n", - "print(pipe.get_current_pressure_distribution()[0])\n", - "print(pipe.get_current_velocity_distribution()*area_pipe)\n", - "print(pipe.get_current_velocity_distribution())" + "V.get_info()" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -146,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -169,2021 +164,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n", - "96532.05564888839\n" - ] - } - ], + "outputs": [], "source": [ "\n", "for it_pipe in range(1,nt):\n", "# for each pipeline timestep, execute nt_eRK4 timesteps of the reservoir code\n", " # set initial conditions for the reservoir time evolution calculted with e-RK4\n", - " V.set_pressure = p_old[0]\n", - " # V.set_outflux = v_old[0]*area_pipe\n", + " V.set_pressure(p_old[0])\n", + " V.set_outflux(v_old[0]*area_pipe)\n", " # calculate the time evolution of the reservoir level within each pipeline timestep to avoid runaway numerical error\n", " for it_res in range(nt_eRK4):\n", " V.timestep_reservoir_evolution() \n", @@ -2224,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ diff --git a/Untertweng.ipynb b/Untertweng.ipynb index 9eedd6d..bc92115 100644 --- a/Untertweng.ipynb +++ b/Untertweng.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -26,7 +26,7 @@ "#Turbine\n", "Q_nenn = 0.85 # m³/s\n", "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", - "closing_time = 30 #s\n", + "closing_time = 5 #s\n", "\n", "# physics\n", "g = 9.81 # gravitational acceleration [m/s²]\n", @@ -38,14 +38,14 @@ "A_pipe = D**2/4*np.pi # pipeline area\n", "h_pipe = 105 # hydraulic head without reservoir [m] \n", "alpha = np.arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \n", - "n = 200 # number of pipe segments in discretization\n", + "n = 50 # number of pipe segments in discretization\n", "# consider replacing Q0 with a vector be be more flexible in initial conditions\n", "# Q0 = Q_nenn # initial flow in whole pipe [m³/s]\n", "# v0 = Q0/A_pipe # initial flow velocity [m/s]\n", "f_D = 0.014 # Darcy friction factor\n", "c = 500. # propagation velocity of the pressure wave [m/s]\n", "# consider prescribing a total simulation time and deducting the number of timesteps from that\n", - "nt = 20000 # number of time steps after initial conditions\n", + "nt = 2500 # number of time steps after initial conditions\n", "\n", "# derivatives of the pipeline constants\n", "dx = L/n # length of each pipe segment\n", @@ -69,7 +69,7 @@ "critical_level_high = np.inf # for yet-to-be-implemented warnings[m]\n", "\n", "# make sure e-RK4 method of reservoir has a small enough timestep to avoid runaway numerical error\n", - "nt_eRK4 = 1000 # number of simulation steps of reservoir in between timesteps of pipeline \n", + "nt_eRK4 = 100 # number of simulation steps of reservoir in between timesteps of pipeline \n", "simulation_timestep = dt/nt_eRK4\n", "\n", "\n" @@ -77,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -90,7 +90,7 @@ "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", "pipe.set_pressure_propagation_velocity(c)\n", "pipe.set_number_of_timesteps(nt)\n", - "pipe.set_steady_state(initial_flux,initial_level,pl_vec,h_vec)\n", + "pipe.set_steady_state(initial_flux,initial_level,area_base,pl_vec,h_vec)\n", "\n", "initial_pressure_turbine = pipe.get_current_pressure_distribution()[-1]\n", "\n", @@ -105,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -142,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -170,21 +170,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# loop through time steps of the pipeline\n", "for it_pipe in range(1,pipe.nt+1):\n", "\n", - " if t_vec[it_pipe]>20:\n", - " if V.get_current_influx() > 0:\n", - " V.set_influx(np.max([V.get_current_influx()-initial_flux*5*1e-3,0.]))\n", + " if it_pipe == 250:\n", + " V.set_influx(0.)\n", "\n", "# for each pipeline timestep, execute nt_eRK4 timesteps of the reservoir code\n", " # set initial conditions for the reservoir time evolution calculted with e-RK4\n", - " V.set_pressure = p_old[0]\n", - " V.set_outflux = v_old[0]*area_outflux\n", + " V.set_pressure(p_old[0])\n", + " V.set_outflux(v_old[0]*area_outflux)\n", " # calculate the time evolution of the reservoir level within each pipeline timestep to avoid runaway numerical error\n", " for it_res in range(nt_eRK4):\n", " V.timestep_reservoir_evolution() \n", @@ -233,7 +232,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n" + ] + } + ], + "source": [ + "print(V.get_current_influx())" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -274,11 +290,57 @@ "fig2.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The cuboid reservoir has the following attributes: \n", + "----------------------------- \n", + "Base area = 74.0 m² \n", + "Outflux area = 0.636 m² \n", + "Current level = 7.875725956447418 m\n", + "Critical level low = 0.0 m \n", + "Critical level high = inf m \n", + "Volume in reservoir = -- m³ \n", + "Current influx = 0.0 m³/s \n", + "Current outflux = -0.1415386124341686 m³/s \n", + "Current outflux vel = -0.222 m/s \n", + "Current pipe pressure = 0.772 bar \n", + "Simulation timestep = 0.0004052 s \n", + "Density of liquid = 1000 kg/m³ \n", + "----------------------------- \n", + "\n", + "9.22707730779877\n", + "10.57842865915012\n", + "11.92978001050147\n", + "13.281131361852822\n", + "14.632482713204173\n", + "15.983834064555523\n", + "17.335185415906874\n", + "18.686536767258225\n", + "20.037888118609576\n", + "21.389239469960927\n" + ] + } + ], + "source": [ + "V.get_info(full=True)\n", + "V.set_outflux(-10.)\n", + "for i in range(10):\n", + " V.level = V.update_level(10.)\n", + " print(V.get_current_level())" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", + "display_name": "Python 3.8.13 ('DT_Slot_3')", "language": "python", "name": "python3" }, @@ -297,7 +359,7 @@ "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" + "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" } } }, From b4bfd017de13bd368ece3675cc78fa32f3ee5aba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Georg=20=C2=B4Brantegger?= Date: Fri, 29 Jul 2022 08:25:23 +0200 Subject: [PATCH 09/11] added safety condition on turbine flux and turbine LA --- Untertweng_mit_Pegelregler.ipynb | 112 +++++++++++++++---------------- 1 file changed, 53 insertions(+), 59 deletions(-) diff --git a/Untertweng_mit_Pegelregler.ipynb b/Untertweng_mit_Pegelregler.ipynb index 8c4669e..5f8ccc0 100644 --- a/Untertweng_mit_Pegelregler.ipynb +++ b/Untertweng_mit_Pegelregler.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -27,7 +27,7 @@ "#Turbine\n", "Q_nenn = 0.85 # m³/s\n", "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", - "closing_time = 70 #s\n", + "closing_time = 30 #s\n", "\n", "# physics\n", "g = 9.81 # gravitational acceleration [m/s²]\n", @@ -51,7 +51,7 @@ "f_D = 0.014 # Darcy friction factor\n", "c = 500. # propagation velocity of the pressure wave [m/s]\n", "# consider prescribing a total simulation time and deducting the number of timesteps from that\n", - "nt = 1000 # number of time steps after initial conditions\n", + "nt = 4500 # number of time steps after initial conditions\n", "\n", "# derivatives of the pipeline constants\n", "dx = L/n # length of each pipe segment\n", @@ -75,7 +75,7 @@ "critical_level_high = np.inf # for yet-to-be-implemented warnings[m]\n", "\n", "# make sure e-RK4 method of reservoir has a small enough timestep to avoid runaway numerical error\n", - "nt_eRK4 = 1000 # number of simulation steps of reservoir in between timesteps of pipeline \n", + "nt_eRK4 = 100 # number of simulation steps of reservoir in between timesteps of pipeline \n", "simulation_timestep = dt/nt_eRK4\n", "\n", "\n" @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -96,20 +96,46 @@ "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", "pipe.set_pressure_propagation_velocity(c)\n", "pipe.set_number_of_timesteps(nt)\n", - "pipe.set_steady_state(initial_flux,initial_level,pl_vec,h_vec)\n", + "pipe.set_steady_state(initial_flux,initial_level,area_base,pl_vec,h_vec)\n", "\n", "initial_pressure_turbine = pipe.get_current_pressure_distribution()[-1]\n", "\n", - "T1 = Francis_Turbine(Q_nenn,p_nenn,closing_time,timestep = dt)\n", + "T1 = Francis_Turbine(Q_nenn,p_nenn,closing_time,timestep=dt)\n", "T1.set_steady_state(initial_flux,initial_pressure_turbine)\n", "\n", + "T_in = Francis_Turbine(Q_nenn,p_nenn,closing_time/2,timestep=dt)\n", + "T_in.set_steady_state(initial_flux,p_nenn)\n", + "\n", "Pegelregler = PI_controller_class(target_level,deadband_range,Kp,Ti,dt)\n", "Pegelregler.control_variable = T1.get_current_LA()\n" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current attributes are: \n", + "----------------------------- \n", + "Current flux = -1.0 m³/s \n", + "Current pipe pressure = -1.0 mWS \n", + "Current LA = 90.90909090909089 % \n", + "----------------------------- \n", + "\n" + ] + } + ], + "source": [ + "T_in.get_info()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -137,15 +163,17 @@ "p_boundary_res[0] = p_old[0]\n", "p_boundary_tur[0] = p_old[-1]\n", "\n", - "LA_soll_vec = np.full_like(t_vec,T1.LA)\n", - "LA_ist_vec = np.full_like(t_vec,T1.LA)\n", + "LA_soll_vec = np.full_like(t_vec,T1.get_current_LA())\n", + "LA_ist_vec = np.full_like(t_vec,T1.get_current_LA())\n", "\n", - "\n" + "LA_soll_vec2 = np.full_like(t_vec,T_in.get_current_LA())\n", + "LA_soll_vec2[200:1500] = 0.\n", + "LA_soll_vec2[1500:2500] = 1. \n" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -173,38 +201,21 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.2146505196687856\n" - ] - } - ], - "source": [ - "print(initial_flux/area_outflux)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# loop through time steps of the pipeline\n", "for it_pipe in range(1,pipe.nt+1):\n", "\n", + " T_in.update_LA(LA_soll_vec2[it_pipe])\n", + " T_in.set_pressure(p_nenn)\n", + " V.set_influx(T_in.get_current_Q())\n", "\n", - " if it_pipe > 0.015*(nt+1):\n", - " if V.get_current_influx() > 0:\n", - " V.set_influx(np.max([V.get_current_influx()-initial_flux*5*1e-3,0.]))\n", "# for each pipeline timestep, execute nt_eRK4 timesteps of the reservoir code\n", " # set initial conditions for the reservoir time evolution calculted with e-RK4\n", - " V.set_pressure = p_old[0]\n", - " V.set_outflux = v_old[0]\n", + " V.set_pressure(p_old[0])\n", + " V.set_outflux(v_old[0]*area_outflux)\n", " # calculate the time evolution of the reservoir level within each pipeline timestep to avoid runaway numerical error\n", " for it_res in range(nt_eRK4):\n", " V.timestep_reservoir_evolution() \n", @@ -216,10 +227,9 @@ " \n", " # change the Leitapparatöffnung based on the target value\n", " T1.update_LA(LA_soll_vec[it_pipe])\n", + " LA_ist_vec[it_pipe] = T1.get_current_LA()\n", + "\n", " T1.set_pressure(p_old[-1])\n", - "\n", - " LA_ist_vec[it_pipe] = T1.LA\n", - "\n", " # set boundary conditions for the next timestep of the characteristic method\n", " p_boundary_res[it_pipe] = V.get_current_pressure()\n", " v_boundary_tur[it_pipe] = 1/A_pipe*T1.get_current_Q()\n", @@ -229,6 +239,7 @@ " p_boundary_tur[it_pipe] = pipe.get_current_pressure_distribution()[-1]\n", " v_boundary_res[it_pipe] = pipe.get_current_velocity_distribution()[0]\n", "\n", + "\n", " # perform the next timestep via the characteristic method\n", " pipe.timestep_characteristic_method()\n", "\n", @@ -257,7 +268,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -298,28 +309,11 @@ "fig2.tight_layout()\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0\n" - ] - } - ], - "source": [ - "print(np.sum(v_boundary_res[2500:])*area_outflux)" - ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", + "display_name": "Python 3.8.13 ('DT_Slot_3')", "language": "python", "name": "python3" }, @@ -338,7 +332,7 @@ "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" + "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" } } }, From 0969c29b7da421889dc99ec3037dc74d5c5e8817 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Georg=20=C2=B4Brantegger?= Date: Fri, 29 Jul 2022 08:25:38 +0200 Subject: [PATCH 10/11] missed stageing --- Turbinen/Turbinen_class_file.py | 13 +++++++++++-- Untertweng.ipynb | 14 +++----------- 2 files changed, 14 insertions(+), 13 deletions(-) diff --git a/Turbinen/Turbinen_class_file.py b/Turbinen/Turbinen_class_file.py index e1b3d5a..30e37a0 100644 --- a/Turbinen/Turbinen_class_file.py +++ b/Turbinen/Turbinen_class_file.py @@ -71,7 +71,10 @@ class Francis_Turbine: def get_current_Q(self): # return the flux through the turbine, based on the current pressure in front # of the turbine and the Leitapparatöffnung - self.Q = self.Q_n*(self.LA/self.LA_n)*np.sqrt(self.p/self.p_n) + if self.p < 0: + self.Q = 0 + else: + self.Q = self.Q_n*(self.LA/self.LA_n)*np.sqrt(self.p/self.p_n) return self.Q def get_current_LA(self): @@ -114,7 +117,13 @@ class Francis_Turbine: LA_diff = self.LA-LA_soll # calculate the difference to the target LA LA_diff_max = self.d_LA_max_dt*self.dt # calculate the maximum change in LA based on the given timestep LA_diff = np.sign(LA_diff)*np.min(np.abs([LA_diff,LA_diff_max])) # calulate the correct change in LA - self.set_LA(self.LA-LA_diff,display_warning=False) # set new LA + + LA_new = self.LA-LA_diff + if LA_new < 0.: + LA_new = 0. + elif LA_new > 1.: + LA_new = 1. + self.set_LA(LA_new,display_warning=False) def set_steady_state(self,ss_flux,ss_pressure): # calculate and set steady state LA, that allows the flow of ss_flux at ss_pressure through the diff --git a/Untertweng.ipynb b/Untertweng.ipynb index bc92115..bbd030a 100644 --- a/Untertweng.ipynb +++ b/Untertweng.ipynb @@ -38,10 +38,7 @@ "A_pipe = D**2/4*np.pi # pipeline area\n", "h_pipe = 105 # hydraulic head without reservoir [m] \n", "alpha = np.arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \n", - "n = 50 # number of pipe segments in discretization\n", - "# consider replacing Q0 with a vector be be more flexible in initial conditions\n", - "# Q0 = Q_nenn # initial flow in whole pipe [m³/s]\n", - "# v0 = Q0/A_pipe # initial flow velocity [m/s]\n", + "n = 50 # number of pipe segments in discretization # initial flow velocity [m/s]\n", "f_D = 0.014 # Darcy friction factor\n", "c = 500. # propagation velocity of the pressure wave [m/s]\n", "# consider prescribing a total simulation time and deducting the number of timesteps from that\n", @@ -94,13 +91,8 @@ "\n", "initial_pressure_turbine = pipe.get_current_pressure_distribution()[-1]\n", "\n", - "T1 = Francis_Turbine(Q_nenn,p_nenn,closing_time,timestep = dt)\n", - "T1.set_steady_state(initial_flux,initial_pressure_turbine)\n", - "\n", - "\n", - "# display the attributes of the created reservoir and pipeline object\n", - "# V.get_info(full=True)\n", - "# pipe.get_info()" + "T1 = Francis_Turbine(Q_nenn,p_nenn,closing_time,timestep=dt)\n", + "T1.set_steady_state(initial_flux,initial_pressure_turbine)\n" ] }, { From ed710a73710eb63ff98aadceb4780b49dab2b613 Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Mon, 1 Aug 2022 08:58:11 +0200 Subject: [PATCH 11/11] pre-merge commit working steady state, but still numerical instability at turbine, that leads to runaway after approx 2.5 minutes for 1000 m pipeline --- .../Ausgleichsbecken_class_file.py | 2 +- Untertweng_mit_Pegelregler.ipynb | 51 ++++++------------- 2 files changed, 16 insertions(+), 37 deletions(-) diff --git a/Ausgleichsbecken/Ausgleichsbecken_class_file.py b/Ausgleichsbecken/Ausgleichsbecken_class_file.py index e07c6b7..89faa97 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken/Ausgleichsbecken_class_file.py @@ -77,7 +77,7 @@ class Ausgleichsbecken_class: raise Exception('Initial level was already set once. Use the .update_level(self,timestep) method to update level based on net flux.') def set_level(self,level): - self.level = level + self.level = level def set_influx(self,influx): # sets influx to the reservoir in m³/s diff --git a/Untertweng_mit_Pegelregler.ipynb b/Untertweng_mit_Pegelregler.ipynb index 5f8ccc0..2650f4c 100644 --- a/Untertweng_mit_Pegelregler.ipynb +++ b/Untertweng_mit_Pegelregler.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 9, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -27,7 +27,7 @@ "#Turbine\n", "Q_nenn = 0.85 # m³/s\n", "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", - "closing_time = 30 #s\n", + "closing_time = 30. #s\n", "\n", "# physics\n", "g = 9.81 # gravitational acceleration [m/s²]\n", @@ -37,7 +37,7 @@ "# define controller constants\n", "target_level = 8. # m\n", "Kp = 0.1\n", - "Ti = 10.\n", + "Ti = 7.\n", "deadband_range = 0.05 # m\n", "\n", "\n", @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -112,30 +112,7 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current attributes are: \n", - "----------------------------- \n", - "Current flux = -1.0 m³/s \n", - "Current pipe pressure = -1.0 mWS \n", - "Current LA = 90.90909090909089 % \n", - "----------------------------- \n", - "\n" - ] - } - ], - "source": [ - "T_in.get_info()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -167,13 +144,15 @@ "LA_ist_vec = np.full_like(t_vec,T1.get_current_LA())\n", "\n", "LA_soll_vec2 = np.full_like(t_vec,T_in.get_current_LA())\n", - "LA_soll_vec2[200:1500] = 0.\n", - "LA_soll_vec2[1500:2500] = 1. \n" + "LA_soll_vec2[500:1000] = 0.\n", + "LA_soll_vec2[1000:1500] = 1. \n", + "LA_soll_vec2[1500:2000] = 0.\n", + "LA_soll_vec2[2000:2500] = 0.5 \n" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -201,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -268,7 +247,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -313,7 +292,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('DT_Slot_3')", + "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", "language": "python", "name": "python3" }, @@ -332,7 +311,7 @@ "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" + "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" } } },