From d8501e165a6459a4ba3244fad22ba23d9403f89e Mon Sep 17 00:00:00 2001 From: Brantegger Georg Date: Fri, 20 May 2022 12:14:55 +0200 Subject: [PATCH] added code snipped, that enables the animated drawing of calculated data --- .gitignore | 3 +- functions/volume_change_nb.ipynb | 165 ++++++++++++++++++++++--------- 2 files changed, 121 insertions(+), 47 deletions(-) diff --git a/.gitignore b/.gitignore index 0bc4a4f..d373fe0 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ 2bignored.txt -functions/__pycache__/ \ No newline at end of file +functions/__pycache__/ +.vscode/settings.json diff --git a/functions/volume_change_nb.ipynb b/functions/volume_change_nb.ipynb index 22c6c0b..b92958d 100644 --- a/functions/volume_change_nb.ipynb +++ b/functions/volume_change_nb.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -27,8 +27,8 @@ "from flow_patterns import return_flux_profiles,make_flux_df\n", "\n", "\n", - "t_max = 1000\n", - "timestep = 00.1\n", + "t_max = 100\n", + "timestep = 1\n", "time = np.arange(0,t_max,timestep)\n", "#input identifiers\n", "i_i = 'st_0010_0010'\n", @@ -65,74 +65,147 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "561bc9e68f9a4b0a8f5c8fd67bd781d1", + "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 …" ] }, - "execution_count": 12, "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, "output_type": "display_data" } ], "source": [ - "from matplotlib import pyplot as plt\n", - "df.plot(x='time',y='h_t')^\n", + "# try to draw h_t in an animated way\n", + "%matplotlib widget\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.animation import FuncAnimation\n", "\n", - "fig = plt(df[])\n", - "\n" + "fig, ax = plt.subplots()\n", + "xdata, ydata = [], []\n", + "ln, = plt.plot([], [], 'ro')\n", + "\n", + "def init():\n", + " ax.set_xlim(0, time[-1])\n", + " ax.set_ylim(np.min(h_t)-1,np.max(h_t)+1)\n", + " return ln,\n", + "\n", + "def update(frame):\n", + " xdata.append(time[frame])\n", + " ydata.append(h_t[frame])\n", + " ln.set_data(xdata, ydata)\n", + " return ln,\n", + "\n", + "ani = FuncAnimation(fig, update, frames=np.arange(np.size(time)),\n", + " init_func=init, blit=True)\n", + "plt.show()\n", + "\n", + "frames=np.arange(np.size(time))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "import plotly.express as px\n", - "from plotly.subplots import make_subplots\n", - "import plotly.graph_objects as go\n", - "import plotly.io as pio\n", - "pio.renderers.default = \"vscode\"\n", + "# # plot np.arrays\n", + "# %matplotlib widget\n", + "# from matplotlib import pyplot as plt\n", + "\n", + "# #define color for plot\n", + "# iter_colors = iter(['blue','green','red','yellow'])\n", + "\n", + "# #create figure with 3 stacked subplots\n", + "# fig_data,axs_data = plt.subplots(3,1,figsize=(7,10))\n", + "\n", + "# #preparation for figure legend\n", "\n", "\n", - "fig1 = make_subplots(3,1,subplot_titles=('Height','Volume','Fluxes'))\n", + "# #fill subplots with data and assign handles to the line_objects (, is necessary, because )\n", + "# handle0, = axs_data[0].plot(time,h_t,marker='.',color=next(iter_colors))\n", + "# handle1, = axs_data[1].plot(time,V_t,marker='.',color=next(iter_colors))\n", + "# handle2, = axs_data[2].plot(time,influx,marker='.',color=next(iter_colors))\n", + "# handle3, = axs_data[2].plot(time,outflux,marker='.',color=next(iter_colors))\n", "\n", - "fig1.add_trace(go.Scatter(x=df['time'],y=df['h_t'],name='height',mode='lines+markers',marker=dict(size=5)),row=1,col=1)\n", - "fig1.add_trace(go.Scatter(x=df['time'],y=df['V_t'],name='volume',mode='lines+markers',marker=dict(size=5)),row=2,col=1)\n", - "fig1.add_trace(go.Scatter(x=df['time'],y=df['influx'],name='influx',mode='lines+markers',marker=dict(size=5)),row=3,col=1)\n", - "fig1.add_trace(go.Scatter(x=df['time'],y=df['outflux'],name='outlfux',mode='lines+markers',marker=dict(size=5)),row=3,col=1)\n", "\n", - "fig1.update_xaxes(title_text = 'time',row=1,col=1)\n", - "fig1.update_xaxes(title_text = 'time',row=2,col=1)\n", - "fig1.update_xaxes(title_text = 'time',row=3,col=1)\n", - "fig1.update_yaxes(title_text = 'h(t)',row=1,col=1)\n", - "fig1.update_yaxes(title_text = 'V(t)',row=2,col=1)\n", - "fig1.update_yaxes(title_text = 'Q(t)',row=3,col=1)\n", + "# #set subplot axis labels\n", + "# axs_data[0].set_ylabel(r'$h(t) \\, / \\, \\mathrm{m}$')\n", + "# axs_data[0].set_xlabel(r'$t \\, / \\, \\mathrm{s}$')\n", + "# axs_data[1].set_ylabel(r'$V(t) \\, / \\, \\mathrm{m}$')\n", + "# axs_data[1].set_xlabel(r'$t \\, / \\, \\mathrm{s}$')\n", + "# axs_data[2].set_ylabel(r'$Q(t)\\, / \\, \\mathrm{m^3s^{-1}}$')\n", + "# axs_data[2].set_xlabel(r'$t \\, / \\, \\mathrm{s}$')\n", "\n", - "fig1.update_layout(height=700)\n", + "# #give the axis labels enough space to be shown\n", + "# plt.tight_layout()\n", "\n", - "fig2 = px.scatter(df,x='time',y='h_t',animation_frame='time')\n", - "fig2.update_xaxes(range=[0,100])\n", - "fig2.update_yaxes(range=[0,5])\n", - "fig1.show()\n", - "fig2.show('notebook')" + "# # resize subplot widths, so that the legend can be shown besides them\n", + "# plt.subplots_adjust(right=0.8)\n", + "\n", + "# # add legend\n", + "# handles = [handle0,handle1,handle2,handle3]\n", + "# legend_names = [r'$h(t)$',r'$V(t)$',r'$Q_{in}(t)$',r'$Q_{out}(t)$']\n", + "# fig_data.legend(handles,legend_names,loc = 'upper right')\n", + "\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# #plot with plolty\n", + "# import plotly.express as px\n", + "# from plotly.subplots import make_subplots\n", + "# import plotly.graph_objects as go\n", + "# import plotly.io as pio\n", + "# pio.renderers.default = \"vscode\"\n", + "\n", + "\n", + "# fig1 = make_subplots(3,1,subplot_titles=('Height','Volume','Fluxes'))\n", + "\n", + "# fig1.add_trace(go.Scatter(x=df['time'],y=df['h_t'],name='height',mode='lines+markers',marker=dict(size=5)),row=1,col=1)\n", + "# fig1.add_trace(go.Scatter(x=df['time'],y=df['V_t'],name='volume',mode='lines+markers',marker=dict(size=5)),row=2,col=1)\n", + "# fig1.add_trace(go.Scatter(x=df['time'],y=df['influx'],name='influx',mode='lines+markers',marker=dict(size=5)),row=3,col=1)\n", + "# fig1.add_trace(go.Scatter(x=df['time'],y=df['outflux'],name='outlfux',mode='lines+markers',marker=dict(size=5)),row=3,col=1)\n", + "\n", + "# fig1.update_xaxes(title_text = 'time',row=1,col=1)\n", + "# fig1.update_xaxes(title_text = 'time',row=2,col=1)\n", + "# fig1.update_xaxes(title_text = 'time',row=3,col=1)\n", + "# fig1.update_yaxes(title_text = 'h(t)',row=1,col=1)\n", + "# fig1.update_yaxes(title_text = 'V(t)',row=2,col=1)\n", + "# fig1.update_yaxes(title_text = 'Q(t)',row=3,col=1)\n", + "\n", + "# fig1.update_layout(height=700)\n", + "\n", + "# fig2 = px.scatter(df,x='time',y='h_t',animation_frame='time')\n", + "# fig2.update_xaxes(range=[0,100])\n", + "# fig2.update_yaxes(range=[0,5])\n", + "# fig1.show()\n", + "# fig2.show('notebook')" ] } ],