{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "#Lets have matplotlib \"inline\"\n", "%matplotlib inline\n", "\n", "# Add line profiler\n", "#%load_ext line_profiler\n", "\n", "#Import packages we need\n", "import numpy as np\n", "from matplotlib import animation, rc\n", "from matplotlib import pyplot as plt\n", "from matplotlib.colorbar import ColorbarBase\n", "\n", "from IPython.display import display, HTML\n", "\n", "from enum import Enum\n", "import subprocess\n", "import time\n", "import os\n", "import gc\n", "import datetime\n", "import importlib\n", "import logging\n", "import netCDF4\n", "import json\n", "\n", "import pycuda.driver as cuda\n", "import pycuda.compiler\n", "\n", "try:\n", " from StringIO import StringIO\n", "except ImportError:\n", " from io import StringIO\n", "\n", "from GPUSimulators import Common, IPythonMagic\n", "from GPUSimulators.EE2D_KP07_dimsplit import EE2D_KP07_dimsplit\n", "from GPUSimulators.helpers import InitialConditions, Visualization" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Console logger using level INFO\n", "File logger using level DEBUG to test_schemes.log\n", "Python version 3.7.2 (default, Mar 13 2019, 14:18:46) \n", "[GCC 4.8.5 20150623 (Red Hat 4.8.5-36)]\n" ] } ], "source": [ "%setup_logging --out test_schemes.log my_logger" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Registering my_context in user workspace\n", "PyCUDA version 2018.1.1\n", "CUDA version (10, 1, 0)\n", "Driver version 10010\n", "Using device 0/1 'Tesla P100-PCIE-12GB' (0000:3B:00.0) GPU\n", "Created context handle <36968176>\n", "Using CUDA cache dir /lustre/storeB/users/martinls/src/ShallowWaterGPU/GPUSimulators/cuda_cache\n" ] } ], "source": [ "%cuda_context_handler --no_autotuning my_context " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "#Set large figure sizes as default\n", "rc('figure', figsize=(16.0, 12.0))\n", "rc('animation', html='html5')\n", "rc('animation', bitrate=1800)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def plotVars(rho, rho_u, rho_v, E):\n", " plt.figure()\n", " plt.subplot(1,4,1)\n", " plt.imshow(rho, origin='bottom')\n", " plt.colorbar(orientation='horizontal', pad=0.02, shrink=0.9)\n", "\n", " plt.subplot(1,4,2)\n", " plt.imshow(rho_u, origin='bottom')\n", " plt.colorbar(orientation='horizontal', pad=0.02, shrink=0.9)\n", "\n", " plt.subplot(1,4,3)\n", " plt.imshow(rho_v, origin='bottom')\n", " plt.colorbar(orientation='horizontal', pad=0.02, shrink=0.9)\n", "\n", " plt.subplot(1,4,4)\n", " plt.imshow(E, origin='bottom')\n", " plt.colorbar(orientation='horizontal', pad=0.02, shrink=0.9)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def runSimulation(outfile, t_end, sim_args):\n", " with Common.Timer(\"construct\") as t:\n", " sim = EE2D_KP07_dimsplit(**sim_args)\n", " print(\"Constructed in \" + str(t.secs) + \" seconds\")\n", "\n", " #Create netcdf file and simulate\n", " with Common.DataDumper(outfile, mode='w', clobber=False) as outdata:\n", " outdata.ncfile.createDimension('time', None)\n", " outdata.ncfile.createDimension('x', sim.nx)\n", " outdata.ncfile.createDimension('y', sim.ny)\n", "\n", " #Create variables\n", " outdata.time_var = outdata.ncfile.createVariable('time', np.dtype('float32').char, 'time')\n", " outdata.x_var = outdata.ncfile.createVariable('x', np.dtype('float32').char, 'x')\n", " outdata.y_var = outdata.ncfile.createVariable('y', np.dtype('float32').char, 'y')\n", " outdata.rho_var = outdata.ncfile.createVariable('rho', np.dtype('float32').char, ('time', 'y', 'x'), zlib=True, least_significant_digit=3)\n", " outdata.rho_u_var = outdata.ncfile.createVariable('rho_u', np.dtype('float32').char, ('time', 'y', 'x'), zlib=True, least_significant_digit=3)\n", " outdata.rho_v_var = outdata.ncfile.createVariable('rho_v', np.dtype('float32').char, ('time', 'y', 'x'), zlib=True, least_significant_digit=3)\n", " outdata.E_var = outdata.ncfile.createVariable('E', np.dtype('float32').char, ('time', 'y', 'x'), zlib=True, least_significant_digit=3)\n", " \n", " #Create attributes\n", " def toJson(in_dict):\n", " out_dict = in_dict.copy()\n", "\n", " for key in out_dict:\n", " if isinstance(out_dict[key], np.ndarray):\n", " out_dict[key] = out_dict[key].tolist()\n", " else:\n", " try:\n", " json.dumps(out_dict[key])\n", " except:\n", " out_dict[key] = str(out_dict[key])\n", "\n", " return json.dumps(out_dict)\n", " outdata.ncfile.created = time.ctime(time.time())\n", " outdata.ncfile.sim_args = toJson(sim_args)\n", "\n", " outdata.x_var[:] = np.linspace(0, sim.nx*sim.dx, sim.nx)\n", " outdata.y_var[:] = np.linspace(0, sim.ny*sim.dy, sim.ny)\n", "\n", " progress_printer = Common.ProgressPrinter(n_save, print_every=10)\n", " print(\"Simulating to t={:f}. Estimated {:d} timesteps (dt={:f})\".format(t_end, int(t_end / sim.dt), sim.dt))\n", " for i in range(n_save+1):\n", " #Sanity check simulator\n", " try:\n", " sim.check()\n", " except AssertionError as e:\n", " print(\"Error after {:d} steps (t={:f}: {:s}\".format(sim.simSteps(), sim.simTime(), str(e)))\n", " return outdata.filename\n", "\n", " #Simulate\n", " if (i > 0):\n", " sim.simulate(t_end/n_save)\n", "\n", " #Save to file\n", " #rho = sim.u0[0].download(sim.stream)\n", " rho, rho_u, rho_v, E = sim.download()\n", " outdata.time_var[i] = sim.simTime()\n", " outdata.rho_var[i, :] = rho\n", " outdata.rho_u_var[i, :] = rho_u\n", " outdata.rho_v_var[i, :] = rho_v\n", " outdata.E_var[i, :] = E\n", "\n", " #Write progress to screen\n", " print_string = progress_printer.getPrintString(i)\n", " if (print_string):\n", " print(print_string)\n", "\n", " return outdata.filename " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "class VisType(Enum):\n", " Schlieren = 0\n", " Density = 1\n", "\n", "def createAnimation(infile, vis_type, vmin, vmax, save_anim=False, cmap=plt.cm.coolwarm, fig_args=None):\n", " fig = plt.figure(**fig_args)\n", " \n", " with Common.DataDumper(infile, 'r') as indata:\n", " time = indata.ncfile.variables['time'][:]\n", " x = indata.ncfile.variables['x'][:]\n", " y = indata.ncfile.variables['y'][:]\n", " rho = indata.ncfile.variables['rho'][0]\n", " rho_u = indata.ncfile.variables['rho_u'][0]\n", " rho_v = indata.ncfile.variables['rho_v'][0]\n", " \n", " created = indata.ncfile.created\n", " sim_args = json.loads(indata.ncfile.sim_args)\n", " for key in sim_args:\n", " if isinstance(sim_args[key], list):\n", " sim_args[key] = \"[...]\"\n", " num_frames = len(time)\n", " print(\"{:s} created {:s} contains {:d} timesteps\".format(infile, created, num_frames))\n", " print(\"Simulator arguments: \\n\", sim_args)\n", "\n", " ax1 = fig.gca()\n", " extents = [0, x.max(), 0, y.max()]\n", " \n", " if (vis_type == VisType.Schlieren):\n", " im = ax1.imshow(Visualization.genColors(rho, rho_u, rho_v, cmap, vmax, vmin), origin='bottom', extent=extents, cmap='gray', vmin=0.0, vmax=1.0)\n", " fig.suptitle(\"Schlieren / vorticity at t={:.2f}\".format(time[0]))\n", " elif (vis_type == VisType.Density):\n", " im = ax1.imshow(rho, origin='bottom', extent=extents, cmap=cmap, vmin=vmin, vmax=vmax)\n", " fig.suptitle(\"Density at t={:.2f}\".format(time[0]))\n", " else:\n", " assert False, \"Wrong vis_type\"\n", "\n", " #Create colorbar\n", " from matplotlib.colors import Normalize\n", " from mpl_toolkits.axes_grid1 import make_axes_locatable\n", " divider = make_axes_locatable(ax1)\n", " ax2 = divider.append_axes(\"right\", size=0.1, pad=0.05)\n", " cb1 = ColorbarBase(ax2, cmap=cmap,\n", " norm=Normalize(vmin=vmin, vmax=vmax),\n", " orientation='vertical')\n", " \n", " #Label colorbar\n", " if (vis_type == VisType.Schlieren):\n", " cb1.set_label('Vorticity')\n", " elif (vis_type == VisType.Density):\n", " cb1.set_label('Density')\n", "\n", " progress_printer = Common.ProgressPrinter(num_frames, print_every=5)\n", " \n", " def animate(i):\n", " rho = indata.ncfile.variables['rho'][i]\n", " rho_u = indata.ncfile.variables['rho_u'][i]\n", " rho_v = indata.ncfile.variables['rho_v'][i]\n", " \n", " if (vis_type == VisType.Schlieren):\n", " im.set_data(Visualization.genColors(rho, rho_u, rho_v, cmap, vmax, vmin))\n", " fig.suptitle(\"Schlieren / vorticity at t={:.2f}\".format(time[i]))\n", " elif (vis_type == VisType.Density):\n", " im.set_data(rho) \n", " fig.suptitle(\"Density at t={:.2f}\".format(time[i]))\n", " \n", " #Write progress to screen\n", " print_string = progress_printer.getPrintString(i)\n", " if (print_string):\n", " print(print_string)\n", "\n", " anim = animation.FuncAnimation(fig, animate, interval=50, frames=range(num_frames))\n", " plt.close()\n", "\n", " if (save_anim):\n", " root, _ = os.path.splitext(infile)\n", " movie_outpath = os.path.abspath(root + \".mp4\")\n", " if (os.path.isfile(movie_outpath)):\n", " print(\"Reusing previously created movie \" + movie_outpath)\n", " else:\n", " print(\"Creating movie \" + movie_outpath)\n", " #from matplotlib.animation import FFMpegFileWriter\n", " #writer = FFMpegFileWriter(fps=25)\n", " from matplotlib.animation import FFMpegWriter\n", " writer = FFMpegWriter(fps=25)\n", " anim.save(movie_outpath, writer=writer)\n", " display(HTML(\"\"\"\n", "
\n", " \n", "
\n", " \"\"\".format(movie_outpath)))\n", " else:\n", " #plt.rcParams[\"animation.html\"] = \"html5\"\n", " plt.rcParams[\"animation.html\"] = \"jshtml\"\n", " display(anim)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Shock-bubble" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "nx = 400\n", "arguments = InitialConditions.genShockBubble(nx, nx//4, 1.4)\n", "plt.figure()\n", "plt.imshow(Visualization.genSchlieren(arguments['rho']), cmap='gray')\n", "plt.colorbar(orientation='vertical', aspect=20, pad=0.02, shrink=0.3)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Initialized /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_shock-bubble_0001.nc\n", "Opening /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_shock-bubble_0001.nc\n", "Keyword arguments: {'mode': 'w', 'clobber': False}\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Constructed in 0.3588526248931885 seconds\n", "Simulating to t=0.500000. Estimated 488 timesteps (dt=0.001023)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Closing /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_shock-bubble_0001.nc\n" ] } ], "source": [ "nx = 800#1600\n", "ny = nx//4\n", "g = 0.0\n", "gamma = 1.4\n", "t_end = 0.5#3.0\n", "n_save = 20#500\n", "outfile = \"data/euler_shock-bubble.nc\"\n", "outdata = None\n", "\n", "arguments = InitialConditions.genShockBubble(nx, ny, gamma)\n", "arguments['context'] = my_context\n", "outfile = runSimulation(outfile, t_end, arguments)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Initialized /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_shock-bubble_0001.nc\n", "Opening /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_shock-bubble_0001.nc\n", "Arguments: ('r',)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "/lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_shock-bubble_0001.nc created Wed Jun 5 15:23:57 2019 contains 21 timesteps\n", "Simulator arguments: \n", " {'rho': '[...]', 'rho_u': '[...]', 'rho_v': '[...]', 'E': '[...]', 'nx': 800, 'ny': 200, 'dx': 0.005, 'dy': 0.005, 'g': 0.0, 'gamma': 1.4, 'boundary_conditions': '[north=Type.Reflective, south=Type.Reflective, east=Type.Periodic, west=Type.Periodic]', 'context': 'CudaContext id 36968176'}\n" ] }, { "data": { "text/html": [ "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", " \n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", " Once \n", " Loop \n", " Reflect \n", "
\n", "
\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Closing /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_shock-bubble_0001.nc\n" ] } ], "source": [ "#outfile = 'data/euler_shock-bubble_0008.nc'\n", "createAnimation(outfile, vis_type=VisType.Schlieren, vmin=-0.2, vmax=0.2, cmap=plt.cm.RdBu, save_anim=False, fig_args={'figsize':(16, 5)})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Kelvin-Helmholtz" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "nx = 400\n", "arguments = InitialConditions.genKelvinHelmholtz(nx, nx//4, 1.4)\n", "\n", "plt.figure()\n", "plt.imshow(arguments['rho'])\n", "plt.colorbar(orientation='vertical', aspect=20, pad=0.02, shrink=0.3)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Initialized /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_kelvin_helmholtz.nc\n", "Opening /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_kelvin_helmholtz.nc\n", "Keyword arguments: {'mode': 'w', 'clobber': False}\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Constructed in 0.0070590972900390625 seconds\n", "Simulating to t=10.000000. Estimated 4346 timesteps (dt=0.002301)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Closing /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_kelvin_helmholtz.nc\n" ] } ], "source": [ "nx = 400\n", "ny = nx//2\n", "roughness = 0.125\n", "t_end = 10.0\n", "n_save = 100#1000\n", "outfile = \"data/euler_kelvin_helmholtz.nc\"\n", "outdata = None\n", "\n", "arguments = InitialConditions.genKelvinHelmholtz(nx, ny, gamma, roughness)\n", "arguments['context'] = my_context\n", "outfile = runSimulation(outfile, t_end, arguments)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Initialized /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_kelvin_helmholtz.nc\n", "Opening /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_kelvin_helmholtz.nc\n", "Arguments: ('r',)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "/lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_kelvin_helmholtz.nc created Wed Jun 5 15:24:26 2019 contains 101 timesteps\n", "Simulator arguments: \n", " {'rho': '[...]', 'rho_u': '[...]', 'rho_v': '[...]', 'E': '[...]', 'nx': 400, 'ny': 200, 'dx': 0.005, 'dy': 0.005, 'g': 0.0, 'gamma': 1.4, 'boundary_conditions': '[north=Type.Periodic, south=Type.Periodic, east=Type.Periodic, west=Type.Periodic]', 'context': 'CudaContext id 36968176'}\n", "0% [##########====================] 100%. Total: 15s, elapsed: 5s, remaining: 10s\n", "0% [###################===========] 100%. Total: 16s, elapsed: 10s, remaining: 5s\n", "0% [############################==] 100%. Total: 16s, elapsed: 15s, remaining: 1s\n" ] }, { "data": { "text/html": [ "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", " \n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", " Once \n", " Loop \n", " Reflect \n", "
\n", "
\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Closing /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_kelvin_helmholtz.nc\n" ] } ], "source": [ "#outfile='data/euler_kelvin_helmholtz_0012.nc'\n", "createAnimation(outfile, vis_type=VisType.Density, vmin=1.0, vmax=2.0, save_anim=False, fig_args={'figsize':(16, 9)})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Rayleigh-Taylor\n", "\n", "* Liska and Wendroff, COMPARISON OF SEVERAL DIFFERENCE SCHEMES ON 1D AND 2D TEST PROBLEMS FOR THE EULER EQUATIONS, http://www-troja.fjfi.cvut.cz/~liska/CompareEuler/compare8.pdf\n", "* https://www.astro.princeton.edu/~jstone/Athena/tests/rt/rt.html\n", "* " ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "nx = 400\n", "arguments = InitialConditions.genRayleighTaylor(nx, nx*3, 1.4, version=0)\n", "plotVars(arguments['rho'], arguments['rho_u'], arguments['rho_v'], arguments['E'])" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Initialized /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_rayleigh-taylor.nc\n", "Opening /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_rayleigh-taylor.nc\n", "Keyword arguments: {'mode': 'w', 'clobber': False}\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Constructed in 0.005157947540283203 seconds\n", "Simulating to t=30.000000. Estimated 15160 timesteps (dt=0.001979)\n", "0% [#######################=======] 100%. Total: 13s, elapsed: 10s, remaining: 3s\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Closing /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_rayleigh-taylor.nc\n" ] } ], "source": [ "nx = 151\n", "ny = nx*3\n", "g = 0.1\n", "gamma = 1.4\n", "t_end = 30\n", "n_save = 300\n", "outfile = \"data/euler_rayleigh-taylor.nc\"\n", "outdata = None\n", "\n", "arguments = InitialConditions.genRayleighTaylor(nx, ny, gamma)\n", "arguments['context'] = my_context\n", "outfile = runSimulation(outfile, t_end, arguments)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Initialized /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_rayleigh-taylor.nc\n", "Opening /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_rayleigh-taylor.nc\n", "Arguments: ('r',)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "/lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_rayleigh-taylor.nc created Wed Jun 5 15:25:06 2019 contains 301 timesteps\n", "Simulator arguments: \n", " {'rho': '[...]', 'rho_u': '[...]', 'rho_v': '[...]', 'E': '[...]', 'nx': 151, 'ny': 453, 'dx': 0.0033112582781456954, 'dy': 0.0033112582781456954, 'g': 0.1, 'gamma': 1.4, 'boundary_conditions': '[north=Type.Reflective, south=Type.Reflective, east=Type.Reflective, west=Type.Reflective]', 'context': 'CudaContext id 36968176'}\n", "0% [########======================] 100%. Total: 18s, elapsed: 5s, remaining: 13s\n", "0% [################==============] 100%. Total: 19s, elapsed: 10s, remaining: 9s\n", "0% [######################========] 100%. Total: 20s, elapsed: 15s, remaining: 5s\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Animation size has reached 21011508 bytes, exceeding the limit of 20971520.0. If you're sure you want a larger animation embedded, set the animation.embed_limit rc parameter to a larger value (in MB). This and further frames will be dropped.\n" ] }, { "data": { "text/html": [ "\n", "\n", "\n", "\n", "
\n", " \n", "
\n", " \n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", " Once \n", " Loop \n", " Reflect \n", "
\n", "
\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "Closing /lustre/storeB/users/martinls/src/ShallowWaterGPU/data/euler_rayleigh-taylor.nc\n" ] } ], "source": [ "#outfile = 'data/euler_rayleigh-taylor_0007.nc'\n", "createAnimation(outfile, vis_type=VisType.Density, vmin=1, vmax=2, cmap=plt.cm.coolwarm, save_anim=False, fig_args={'figsize':(3.4, 8)})" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.7.2" } }, "nbformat": 4, "nbformat_minor": 2 }