probably working combined code :D

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

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)+ \
+    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, p))
+        2*FODE_function(Y3, h_hs, alpha, p_hs)+ FODE_function(Y4, h, alpha, p0))
 

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"
    }
   }
  },

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"Length per segments    =       {self.dx:<10} {self.length_unit_print} {new_line}"
-            f"Pipeline angle        =       {self.angle:<10} {self.angle_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")

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",
+    "h_pipe  = 200              # hydraulic head without reservoir [m] \n",
-    "alpha   = arcsin(h_pipe/L)  # Höhenwinkel der Druckrohrleitung \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",
+    "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_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"
    }
   }
  },

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
+}