From b03bb43c63e0b8f65a0ae77fe5c09e9a1f2a0e39 Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Tue, 5 Jul 2022 16:02:55 +0200 Subject: [PATCH] probably working combined code :D --- .../Ausgleichsbecken_class_file.py | 7 +- .../Ausgleichsbecken_functions.py | 4 +- Ausgleichsbecken/Main_Program.ipynb | 10 +- .../Druckrohrleitung_class_file.py | 8 +- Druckrohrleitung/Main_Programm.ipynb | 58 ++-- combine_pipeline_and_reservoir.ipynb | 272 ++++++++++++++++++ 6 files changed, 326 insertions(+), 33 deletions(-) create mode 100644 combine_pipeline_and_reservoir.ipynb diff --git a/Ausgleichsbecken/Ausgleichsbecken_class_file.py b/Ausgleichsbecken/Ausgleichsbecken_class_file.py index 4956637..1b5378a 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken/Ausgleichsbecken_class_file.py @@ -1,5 +1,5 @@ import numpy as np -from Ausgleichsbecken_functions import FODE_function, get_h_halfstep, get_p_halfstep +# from Ausgleichsbecken_functions import FODE_function, get_h_halfstep, get_p_halfstep #importing pressure conversion function import sys @@ -9,6 +9,11 @@ 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) + return f + + class Ausgleichsbecken_class: # units # make sure that units and print units are the same diff --git a/Ausgleichsbecken/Ausgleichsbecken_functions.py b/Ausgleichsbecken/Ausgleichsbecken_functions.py index ac2ddca..37e5450 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_functions.py +++ b/Ausgleichsbecken/Ausgleichsbecken_functions.py @@ -25,6 +25,6 @@ def e_RK_4(yn, h, dt, Q0, Q1, A0, A1, p0, p1): Y2 = yn + dt/2*FODE_function(Y1, h, alpha, p0) Y3 = yn + dt/2*FODE_function(Y2, h_hs, alpha, p_hs) Y4 = yn + dt*FODE_function(Y3, h_hs, alpha, p_hs) - ynp1 = yn + dt/6*(FODE_function(Y1, h, alpha, p)+2*FODE_function(Y2, h_hs, alpha, p_hs)+ \ - 2*FODE_function(Y3, h_hs, alpha, p_hs)+ FODE_function(Y4, h, alpha, p)) + ynp1 = yn + dt/6*(FODE_function(Y1, h, alpha, p0)+2*FODE_function(Y2, h_hs, alpha, p_hs)+ \ + 2*FODE_function(Y3, h_hs, alpha, p_hs)+ FODE_function(Y4, h, alpha, p0)) diff --git a/Ausgleichsbecken/Main_Program.ipynb b/Ausgleichsbecken/Main_Program.ipynb index 2d51217..9a76e26 100644 --- a/Ausgleichsbecken/Main_Program.ipynb +++ b/Ausgleichsbecken/Main_Program.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -133,7 +133,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" }, @@ -152,7 +152,7 @@ "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" + "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" } } }, diff --git a/Druckrohrleitung/Druckrohrleitung_class_file.py b/Druckrohrleitung/Druckrohrleitung_class_file.py index 815c49c..fe1f104 100644 --- a/Druckrohrleitung/Druckrohrleitung_class_file.py +++ b/Druckrohrleitung/Druckrohrleitung_class_file.py @@ -116,14 +116,14 @@ class Druckrohrleitung_class: f"----------------------------- {new_line}" f"Length = {self.length:<10} {self.length_unit_print} {new_line}" f"Diameter = {self.dia:<10} {self.length_unit_print} {new_line}" - f"Number of segemnts = {self.n_seg:<10} {new_line}" + f"Number of segments = {self.n_seg:<10} {new_line}" f"Number of nodes = {self.n_seg+1:<10} {new_line}" - f"Length per segment = {self.dx:<10} {self.length_unit_print} {new_line}" - f"Pipeline angle = {self.angle:<10} {self.angle_unit_print} {new_line}" + f"Length per segments = {self.dx:<10} {self.length_unit_print} {new_line}" + f"Pipeline angle = {round(self.angle,3):<10} {self.angle_unit_print} {new_line}" f"Darcy friction factor = {self.f_D:<10} {new_line}" f"Density of liquid = {self.density:<10} {self.density_unit_print} {new_line}" f"Pressure wave vel. = {self.c:<10} {self.velocity_unit_print} {new_line}" - f"Simulation timesteps = {self.dt:<10} {self.time_unit_print } {new_line}" + f"Simulation timestep = {self.dt:<10} {self.time_unit_print } {new_line}" f"Number of timesteps = {self.nt:<10} {new_line}" f"----------------------------- {new_line}" f"Velocity and pressure distribution are vectors and are accessible by the .v and .p attribute of the pipeline object") diff --git a/Druckrohrleitung/Main_Programm.ipynb b/Druckrohrleitung/Main_Programm.ipynb index fbcc88c..fca1668 100644 --- a/Druckrohrleitung/Main_Programm.ipynb +++ b/Druckrohrleitung/Main_Programm.ipynb @@ -2,12 +2,11 @@ "cells": [ { "cell_type": "code", - "execution_count": 52, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", - "from numpy import sin, arcsin\n", "from Druckrohrleitung_class_file import Druckrohrleitung_class\n", "import matplotlib.pyplot as plt\n", "\n", @@ -22,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -40,8 +39,8 @@ "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 = 1e-5 # hydraulic head without reservoir [m] \n", - "alpha = arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \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", @@ -79,7 +78,7 @@ " 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*sin(alpha)-f_D*dt/(2*D)*abs(v_old[1])*v_old[1]\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", @@ -87,7 +86,7 @@ "\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*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", + " +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", @@ -109,11 +108,11 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "pipe = Druckrohrleitung_class(L,D,n,0,f_D)\n", + "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", @@ -134,12 +133,12 @@ "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$ [Pa]')\n", + "axs2[0].set_ylabel(r'$p$ [mWS]')\n", "axs2[1].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", - "axs2[1].set_ylabel(r'$p$ [Pa]')\n", - "lo_00, = axs2[0].plot(pl_vec,pressure_conversion(pipe.p_old,'Pa','mWs')[0],marker='.')\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([-5*np.max(pressure_conversion(pipe.p_old,'Pa','mWs')[0]),5*np.max(pressure_conversion(pipe.p_old,'Pa','mWs')[0])])\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", @@ -147,7 +146,7 @@ "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(pipe.p)\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", @@ -165,35 +164,52 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "fig3,axs3 = plt.subplots(2,2)\n", - "axs3[0,0].plot(t_vec,pipe.p_0)\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,pipe.p_np1)\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$ [Pa]')\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$ [Pa]')\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 ('DT_Slot_3')", + "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", "language": "python", "name": "python3" }, @@ -212,7 +228,7 @@ "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" + "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" } } }, diff --git a/combine_pipeline_and_reservoir.ipynb b/combine_pipeline_and_reservoir.ipynb new file mode 100644 index 0000000..9b62d7f --- /dev/null +++ b/combine_pipeline_and_reservoir.ipynb @@ -0,0 +1,272 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from functions.pressure_conversion import pressure_conversion\n", + "from Ausgleichsbecken.Ausgleichsbecken_class_file import Ausgleichsbecken_class\n", + "from Druckrohrleitung.Druckrohrleitung_class_file import Druckrohrleitung_class\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#define constants\n", + "\n", + "# physics\n", + "g = 9.81 # gravitational acceleration [m/s²]\n", + "rho = 1000. # density of water [kg/m³]\n", + "\n", + "# pipeline\n", + "L = 1000. # length of pipeline [m]\n", + "D = 1. # pipe diameter [m]\n", + "#consider replacing Q0 with a vector be be more flexible in initial conditions\n", + "Q0 = 2 # initial flow in whole pipe [m³/s]\n", + "A_pipe = D**2/4*np.pi # pipeline area\n", + "v0 = Q0/A_pipe # initial flow velocity [m/s]\n", + "h_res = 20. # water level in upstream reservoir [m]\n", + "n = 10 # number of pipe segments in discretization\n", + "nt = 10000 # 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 = 300 # hydraulic head without reservoir [m] \n", + "alpha = np.arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \n", + "\n", + "# derivatives of the pipeline constants\n", + "p0 = rho*g*h_res-v0**2*rho/2\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", + "\n", + "# reservoir\n", + "initial_level = h_res # m\n", + "initial_influx = 0. # m³/s\n", + "initial_outflux = Q0 # m³/s\n", + "initial_pipeline_pressure = p0 # Pa \n", + "initial_pressure_unit = 'Pa'\n", + "conversion_pressure_unit = 'Pa'\n", + "area_base = 5. # m² really large base are to ensure level never becomes < 0\n", + "area_outflux = A_pipe # m²\n", + "critical_level_low = 0. # m\n", + "critical_level_high = np.inf # 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", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3.6368236494728476, 'mWS')\n" + ] + } + ], + "source": [ + "print(pressure_conversion(-np.sum((-v_init**2*rho/2)),'Pa','mWS'))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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_initial_level(initial_level) \n", + "V.set_influx(initial_influx)\n", + "V.set_outflux(initial_outflux)\n", + "V.pressure, V.pressure_unit = pressure_conversion(initial_pipeline_pressure,input_unit = initial_pressure_unit, target_unit = 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_initial_pressure(p_init)\n", + "pipe.set_initial_flow_velocity(v_init)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# initialization for timeloop\n", + "\n", + "v_old = v_init.copy()\n", + "p_old = p_init.copy()\n", + "\n", + "#vectors to store boundary conditions\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", + "level_vec = np.empty_like(t_vec)\n", + "level_vec_2 = np.full([nt_eRK4],initial_level)\n", + "\n", + "v_boundary_res[0] = v_old[0]\n", + "v_boundary_tur[0] = v_old[-1] # instantaneous closing\n", + "# v_boundary_tur[1:] = 0\n", + "v_boundary_tur[0:1000] = np.linspace(v_old[-1],0,1000) # finite closing time - linear case\n", + "p_boundary_res[0] = p_old[0]\n", + "p_boundary_tur[0] = p_old[-1]\n", + "level_vec[0] = initial_level\n", + "\n", + "v_boundary_tur[1:] = 0 # instantaneous closing" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib qt5\n", + "# time loop\n", + "\n", + "\n", + "# fig2,axs2 = plt.subplots(3,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", + "# lo_02, = axs2[2].plot(level_vec_2)\n", + "# axs2[0].autoscale()\n", + "# axs2[1].autoscale()\n", + "# axs2[2].autoscale()\n", + "# fig2.tight_layout()\n", + "\n", + "# loop through time steps of the pipeline\n", + "for it_pipe in range(1,pipe.nt):\n", + "\n", + "# for each pipeline timestep, execute nt_eRK4 timesteps of the reservoir code\n", + " V.pressure = p_old[0]\n", + " V.outflux = v_old[0]\n", + " for it_res in range(nt_eRK4):\n", + " V.e_RK_4()\n", + " V.level = V.update_level(V.timestep)\n", + " V.set_volume()\n", + " level_vec_2[it_res] = V.level\n", + " if (V.level < critical_level_low) or (V.level > critical_level_high):\n", + " i_max = it_pipe\n", + " print('broke')\n", + " break\n", + " level_vec[it_pipe] = V.level\n", + "\n", + " p_boundary_res[it_pipe] = rho*g*V.level-v_old[1]**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", + "\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", + "\n", + " pipe.timestep_characteristic_method()\n", + "\n", + "\n", + " # lo_00.remove()\n", + " # lo_01.remove()\n", + " # lo_02.remove()\n", + " # lo_00, = axs2[0].plot(pl_vec,pressure_conversion(pipe.p_old,'Pa','mWS')[0],marker='.',c='blue')\n", + " # lo_01, = axs2[1].plot(pl_vec,pipe.v_old,marker='.',c='blue')\n", + " # lo_02, = axs2[2].plot(level_vec_2,c='blue')\n", + " # fig2.suptitle(str(it_pipe))\n", + " # fig2.canvas.draw()\n", + " # fig2.canvas.flush_events()\n", + " # fig2.tight_layout()\n", + " # plt.pause(0.1) \n", + "\n", + " p_old = pipe.p_old\n", + " v_old = pipe.v_old \n", + "\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib qt5\n", + "fig1,axs1 = plt.subplots(3,2)\n", + "axs1[0,0].plot(t_vec,pressure_conversion(p_boundary_res,'Pa','mWS')[0])\n", + "axs1[0,1].plot(t_vec,v_boundary_res)\n", + "axs1[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,'Pa','mWS')[0])\n", + "axs1[1,1].plot(t_vec,v_boundary_tur)\n", + "axs1[2,0].plot(t_vec,level_vec)\n", + "axs1[0,0].set_title('Pressure Reservoir')\n", + "axs1[0,1].set_title('Velocity Reservoir')\n", + "axs1[1,0].set_title('Pressure Turbine')\n", + "axs1[1,1].set_title('Velocity Turbine')\n", + "axs1[0,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs1[0,0].set_ylabel(r'$p$ [mWS]')\n", + "axs1[0,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs1[0,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "axs1[1,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs1[1,0].set_ylabel(r'$p$ [mWS]')\n", + "axs1[1,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs1[1,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "fig1.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 +}