{ "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.6.7 |Anaconda custom (64-bit)| (default, Oct 28 2018, 19:44:12) [MSC v.1915 64 bit (AMD64)]\n" ] } ], "source": [ "%setup_logging --out test_schemes.log" ] }, { "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, 0, 0)\n", "Driver version 10000\n", "Using 'GeForce 840M' GPU\n", "Created context handle <346033291232>\n", "Using CUDA cache dir c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\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": "iVBORw0KGgoAAAANSUhEUgAAAzkAAADhCAYAAADrl3vGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAGFVJREFUeJzt3XGsZOV53/Hvj8XECXaC7V1bFHCyTdbF1GrAvsW0SCkB0i60YqmEK0jrEIt2WwkSJzipcVrhlDZSnLahjUTcbgyBRI4xIU5ZWVsTi4CiVoXsrqG2dwlis0awZuvdjYGkcTHZ7NM/5lyYHWbuzNw7d+7Mud+PdHTnnDnznndeXmbPM+/zvpOqQpIkSZLa4pS1roAkSZIkTZJBjiRJkqRWMciRJEmS1CoGOZIkSZJaxSBHkiRJUqsY5EiSJElqFYMcSZIkSWsmyV1JjiT56oDnk+RXkhxI8uUk7x1WpkGOJEmSpLV0N7B1ieevALY023bgk8MKNMiRJEmStGaq6g+Aby5xyjbgN6rjUeCMJGcuVeapk6ygJEmSpPVh69atdezYsSXP2bt37z7g5a5DO6pqx5iXOgt4rmv/UHPs8KAXGORIkiRJGtuxY8fYs2fPkuckebmqFlZ4qfQ5Vku9wCBHkiRJ0rKcOHFiGpc5BJzTtX828PxSL1jRnJwkW5M81ax0cMtKypIkSZI0X6pqyW1CdgI/1qyydhHwUlUNTFWDFYzkJNkA3AH8CJ3oaneSnVW1f7llSpIkSZoPkwpkknwGuATYmOQQ8HHgDc01/guwC7gSOAB8C/jQsDJXkq52IXCgqg42lbuXzsoHBjmSJEnSOjCJdLWqum7I8wXcOE6ZKwly+q1y8P7ek5Jsp7OeNaeffvr7zj333BVc8jV79+599fH73ve+iZQpSZIktd0zzzzDsWPH+k3mH9sEU9ImaiVBzkirHDRLxO0AWFhYqGErMIx88bx2+UmVKUmSJLXdwsJKFzt7TRuDnLFXOZAkSZLUDlU1rdXVxraS1dV2A1uSbE5yGnAtnZUPJEmSJK0DU1pdbWzLHsmpquNJbgIeBDYAd1XVvonVTJIkSdJMa2O6GlW1i86SbpIkSZLWmVYGOZIkSZLWp1mek2OQI0mSJGlZHMmRJEmS1CoGOZIkSZJaw3Q1SZIkSa3jSI4kSZKkVjHIkSRJktQapqtJkiRJah1HciRJkiS1ikGOJEmSpFYxXU2SJElSa1SVIzmSJEmS2sUgR5IkSVKrGORIkiRJahXn5EiSJElqDefkSJIkSWodgxxJkiRJrWK6miRJkqRWcSRHkiRJUms4J0eSJElS65iuJkmSJKlVHMmRJEmS1CoGOZIkSZJao6pMV5MkSZLULrM6knPKWldAkiRJ0nxaXGFt0DaKJFuTPJXkQJJb+jz/ziQPJ3k8yZeTXDmsTIMcSZIkScuy0iAnyQbgDuAK4DzguiTn9Zz2r4H7quoC4FrgV4eVa7qaJEmSpLFNaE7OhcCBqjoIkOReYBuwv/tSwHc3j78HeH5YoQY5kiRJkpZlhNGajUn2dO3vqKodXftnAc917R8C3t9Txs8Dv5fkJ4DTgcuHXXRoulqSc5ocuCeT7Evy4eb4W5N8McnTzd+3DCtLkiRJUnuMkK52rKoWurYdPUWkX7E9+9cBd1fV2cCVwG8mWTKOGWVOznHgI1X1buAi4MYmT+4W4KGq2gI81OxLkiRJWgcW09WW2kZwCDina/9sXp+OdgNwX3PN/wW8Edi4VKFDg5yqOlxVX2oe/xnwJJ1hpW3APc1p9wBXD30LkiRJklpjAqur7Qa2JNmc5DQ6Cwvs7DnnWeAygCTvphPkHF2q0LHm5CT5PuAC4DHgHVV1GDqBUJK3j1OWJEmSpPm20t/JqarjSW4CHgQ2AHdV1b4ktwF7qmon8BHg15L8NJ1Uth+vIRceOchJ8ibgd4Cfqqo/Tfqlz/V93XZgO8A73/nOUS8nSZIkacZNYHU1qmoXsKvn2K1dj/cDF49T5ki/k5PkDXQCnE9X1eeaw99Icmbz/JnAkQGV3rE40WjTpk3j1E2SJEnSjBqWqrbSUZ6VGGV1tQB3Ak9W1S93PbUTuL55fD3wwOSrJ0mSJGlWzWqQM0q62sXAB4GvJHmiOfZzwC8C9yW5gc5koA+sThUlSZIkzaJJpKuthqFBTlX9D/qvXw3NKgeSJEmS1p+1HK1Zylirq0mSJEkSsOYpaUsxyJlTo65uN4pZ7ZySJEmabbN6H2mQM8MmGcgs9zqz2nElSZK09uZ2To4kSZIk9TOrX4gb5MyQcUZuJtmhlrpu73Oz2pElSZI0Xc7JkSRJktQ6pqupr1mYD7PUdXrr58iOJEmSFs3qvaBBjiRJkqRlMcjRSfqN4MxiJ+mt06CRnVmsuyRJklZPVZmuJkmSJKldZvWLboOcKRk092ZWO8Ygg0Z2ut/fvL0nSZIkLc+s3vcZ5EiSJEkam+lq61hbRnAGWXwf3e/TeTqSJEnrw6ze7xnkSJIkSVoWg5x1Zr39nkz3++udp9P29y5JkrRezep9nkGOJEmSpLE5J2edWe8rjfXO03FER5IkqZ1m9f7OIGeC1ntw08tgR5Ikqd1m9b7OIEeSJEnSspiu1mLrbZGBcTmiI0mS1D5VNbP3cwY5kiRJkpbFIEeSJElSq5iuJkmSJKlVHMlpIefijMe5OZIkSe3hnBxJkiRJrWO6Wos4grMy/UZ0bENJkqT5M6v3cKesdQUkSZIkzZ/FdLWltlEk2ZrkqSQHktwy4Jx/lGR/kn1JfmtYmY7kSJIkSVqWlY7kJNkA3AH8CHAI2J1kZ1Xt7zpnC/Ax4OKqeiHJ24eVO/JITpINSR5P8vlmf3OSx5I8neSzSU4b901JkiRJml8nTpxYchvBhcCBqjpYVa8A9wLbes75Z8AdVfUCQFUdGVboOOlqHwae7Nr/BHB7VW0BXgBuGKOsuZTkpPk4s7yixDzobr/etpUkSdLsm0C62lnAc137h5pj3d4FvCvJ/0zyaJKtwwodKchJcjbw94FPNfsBLgXub065B7h6lLIkSZIkzb8R5+RsTLKna9veU0y/b7l7o6NTgS3AJcB1wKeSnLFU3Uadk/OfgH8JvLnZfxvwYlUdb/b7RVySJEmSWmyElLRjVbWwxPOHgHO69s8Gnu9zzqNV9RfA15I8RSfo2T2o0KEjOUn+AXCkqvZ2H+5zat/xqCTbFyO3o0ePDrvcTDJNbXV1t6Vpa5IkSfNjAulqu4EtzXz/04BrgZ095/w34IcBkmykk752cKlCR0lXuxi4KskzdCYCXUpnZOeMJIsjQf0iLgCqakdVLVTVwqZNm0a4nCRJkqR5sNIgp8kMuwl4kM78//uqal+S25Jc1Zz2IPAnSfYDDwM/W1V/slS5Q9PVqupjdJZsI8klwM9U1T9O8tvANXQCn+uBB4a+C0mSJEmtUFWjrqA2rJxdwK6eY7d2PS7g5mYbyUp+DPSjwM1JDtCZo3PnCsqSJEmSNGcm8WOgq2GsHwOtqkeAR5rHB+msay1JkiRpHZrVeepjBTmSJEmSBJNLV1sNBjmSJEmSlsWRHEmSJEmtYpAzp3p/H0erY7FtF9t78a9tLkmSNLtMV5MkSZLUGmu9gtpSDHIkSZIkLYtBjiRJkqRWMciRJEmS1CrOyZEkSZLUGs7JkSRJktQ6BjmSJEmSWsV0NUmSJEmt4kiOJEmSpNZwTo4kSZKk1jFdTZIkSVKrOJIjSZIkqVUMciRJkiS1RlWZriZJkiSpXRzJkSRJktQqBjmSJEmSWsUgR5IkSVJrOCdnjlUVSQBe/TurEes8W2zbRbaxJEnS7JvVezaDHEmSJEnLYpAjSZIkqTVMV5MkSZLUOo7kSJIkSWoVgxxJkiRJrWK6miRJkqTWqKqZHck5ZZSTkpyR5P4kf5TkySR/K8lbk3wxydPN37esdmUlSZIkzY7FQGfQtlZGCnKA/wx8oarOBX4QeBK4BXioqrYADzX7rdT7HynJ637XRcvX3ZZr/T+EJEmSRnfixIklt1Ek2ZrkqSQHkgyMKZJck6SSLAwrc2iQk+S7gR8C7gSoqleq6kVgG3BPc9o9wNWjvAlJkiRJ7bDSkZwkG4A7gCuA84DrkpzX57w3Az8JPDZKvUYZyfmrwFHg15M8nuRTSU4H3lFVh5s3dxh4+ygXlCRJkjT/hgU4I2bnXAgcqKqDVfUKcC+dwZRe/xb4JeDlUQodJcg5FXgv8MmqugD4c8ZITUuyPcmeJHuOHj066stmkmlrk9XdfqapSZIkzZ8RgpyNi7FAs23vKeIs4Lmu/UPNsVcluQA4p6o+P2q9Rlld7RBwqKoWh4bupxPkfCPJmVV1OMmZwJF+L66qHcAOgIWFBe9iJUmSpJYYYd7Nsapaag5NvxGDV2OGJKcAtwM/Pk69ho7kVNX/AZ5L8teaQ5cB+4GdwPXNseuBB8a5sCRJkqT5NoF0tUPAOV37ZwPPd+2/GXgP8EiSZ4CLgJ3DFh8Y9XdyfgL4dJLTgIPAh+gESPcluQF4FvjAiGVJkiRJmnMTmm6wG9iSZDPwdeBa4Ee7rvESsHFxP8kjwM9U1Z6lCh0pyKmqJ4B+0dJlo7y+bRb/Yy7OJ+meV6Lheucx2W6SJEnzadRlogepquNJbgIeBDYAd1XVviS3AXuqaudyyh11JEeSJEmSTjKJL6urahewq+fYrQPOvWSUMg1yVsARnfE4giNJktQus3o/Z5AjSZIkaWxVteJ0tdVikCNJkiRpWRzJkSRJktQqBjkt1m9uzqz+B18LzsWRJElqH9PVJEmSJLXOrH55bZAzQd0jOq605giOJElS283q/Z1BziqoqnW9rLTBjSRJ0vowq/d5BjmSJEmSxuacnHVo0A+F9j7fFr3vD9r3HiVJknSyWb3fM8iRJEmStCwGOetU74jOorbM1XEER5IkaX0yXU2SJElS68zql9sGOVPS2wH6zdWZ1U7Srd/IDcxH3SVJkjRZs3oPaJAjSZIkaVlMV9NJ+s3VmcUV2AaN3CyahTpKkiRp+qpqZu8FDXIkSZIkLYtBjvrq7hiDVmAb9rqVGjZas1rXlSRJ0nwzXU2SJElSq8zqF+AGOTNk0Aps/Ywz+rISs9pxJUmStLack6NlWarTTDLImdXOKUmSpNk2q/eRBjmSJEmSlsU5OZqoWY2aJUmStH7M6j2pQY4kSZKksTknR5IkSVLrmK4mSZIkqVUcyZEkSZLUKgY5kiRJklqjqmY2Xe2UUU5K8tNJ9iX5apLPJHljks1JHkvydJLPJjlttSsrSZIkaXYsLj4waFsrQ4OcJGcBPwksVNV7gA3AtcAngNuragvwAnDDalZUkiRJ0myZ2yCncSrwnUlOBb4LOAxcCtzfPH8PcPXkqydJkiRpFi2mqy21jSLJ1iRPJTmQ5JY+z9+cZH+SLyd5KMn3DitzaJBTVV8H/gPwLJ3g5iVgL/BiVR1vTjsEnDWg0tuT7Emy5+jRo8MuJ0mSJGlOrHQkJ8kG4A7gCuA84Lok5/Wc9jidrLK/QWeQ5ZeGlTtKutpbgG3AZuCvAKc3lejV911U1Y6qWqiqhU2bNg27nCRJkqQ5MYF0tQuBA1V1sKpeAe6lE3t0X+PhqvpWs/socPawQkdJV7sc+FpVHa2qvwA+B/xt4IwmfY3mQs+P8i4kSZIktcMIQc7GxayuZtveU8RZwHNd+wMzxBo3AP99WL1GWUL6WeCiJN8F/D/gMmAP8DBwDZ1o63rggRHKkiRJktQCIy4hfayqFpZ4Pv2K7nti8k+ABeDvDLvoKHNyHqOT+/Yl4CvNa3YAHwVuTnIAeBtw57CyJEmSJLXHBNLVDgHndO33zRBLcjnwr4Crqurbwwod6cdAq+rjwMd7Dh+kk0MnSZIkaR2awDLRu4EtSTYDX6fzUzU/2n1CkguA/wpsraojoxQ6UpAjSZIkSb1GXSZ6kKo6nuQm4EE6v8d5V1XtS3IbsKeqdgL/HngT8NtJAJ6tqquWKtcgR5IkSdLYJvWDn1W1C9jVc+zWrseXj1umQY4kSZKkZZlEkLMaDHIkSZIkLctK09VWi0GOJEmSpGVxJEeSJElSa0xqTs5qMMiRJEmStCymq0mSJElqFUdyJEmSJLWKQY4kSZKk1nBOjiRJkqTWcU6OJEmSpFZxJEeSJElSqxjkSJIkSWqNqjJdTZIkSVK7OJIjSZIkqVUMciRJkiS1hulqkiRJklrHkRxJkiRJrWKQI0mSJKlVTFeTJEmS1BpV5UiOJEmSpHYxyJEkSZLUKgY5kiRJklrFOTmSJEmSWsM5OZIkSZJaxyBHkiRJUquYriZJkiSpVRzJkSRJktQazsmRJEmS1DqmqwF79+49luTPgWOTLDfJJItrm41MuL01lG0+fbb5dNne02ebT59tPl2293R976QKciQHqKpNSfZU1cI0r7ue2d7TZ5tPn20+Xbb39Nnm02ebT5ftPb9mNcg5Za0rIEmSJGn+VBUnTpxYchtFkq1JnkpyIMktfZ7/jiSfbZ5/LMn3DSvTIEeSJEnSsiwuPjBoGybJBuAO4ArgPOC6JOf1nHYD8EJV/QBwO/CJYeWuRZCzYw2uuZ7Z3tNnm0+fbT5dtvf02ebTZ5tPl+09p1Ya5AAXAgeq6mBVvQLcC2zrOWcbcE/z+H7gsgyZlJ9ZzaOTJEmSNLuSfIHOohFLeSPwctf+jqp6NahNcg2wtar+abP/QeD9VXVT1zlfbc451Oz/cXPOwMUqXEJakiRJ0tiqausEiuk3ItM7CjPKOSdxTo4kSZKktXIIOKdr/2zg+UHnJDkV+B7gm0sVOrUgZ9iqCZqMJM8k+UqSJ5LsaY69NckXkzzd/H3LWtdzniW5K8mRZuh08VjfNk7HrzT9/stJ3rt2NZ9PA9r755N8vennTyS5suu5jzXt/VSSv7c2tZ5vSc5J8nCSJ5PsS/Lh5rj9fBUs0d7281WS5I1J/jDJ/27a/N80xzc3Kzc93azkdFpzfOyVnfSaJdr77iRf6+rj5zfH/UxZX3YDW5r//04DrgV29pyzE7i+eXwN8Ps1ZM7NVIKcEVdN0OT8cFWd37Xe/C3AQ1W1BXio2dfy3Q30Ds8OauMrgC3Nth345JTq2CZ38/r2Bri96efnV9UugOZz5Vrgrzev+dXm80fjOQ58pKreDVwE3Ni0rf18dQxqb7Cfr5ZvA5dW1Q8C5wNbk1xEZ8Wm25s+/gKdFZ1gGSs76SSD2hvgZ7v6+BPNMT9T1pGqOg7cBDwIPAncV1X7ktyW5KrmtDuBtyU5ANzMCPey0xrJGWXVBK2e7hUp7gGuXsO6zL2q+gNeP0Q6qI23Ab9RHY8CZyQ5czo1bYcB7T3INuDeqvp2VX0NOEDn80djqKrDVfWl5vGf0flH5yzs56tiifYexH6+Qk1f/b/N7huarYBL6azcBK/v42Ot7KTXLNHeg/iZss5U1a6qeldVfX9V/UJz7Naq2tk8frmqPlBVP1BVF1bVwWFlTivIOQt4rmv/EEt/gGv5Cvi9JHuTbG+OvaOqDkPnH1Pg7WtWu/Ya1Mb2/dVzU5PGcFdXCqbtPWFNWs4FwGPYz1ddT3uD/XzVJNmQ5AngCPBF4I+BF5tvleHkdn21zZvnXwLeNt0az7fe9q6qxT7+C00fvz3JdzTH7ONasWkFOWOviKBlu7iq3ktnqPfGJD+01hVa5+z7q+OTwPfTSXs4DPzH5rjtPUFJ3gT8DvBTVfWnS53a55jtPqY+7W0/X0VV9ZdVdT6dSc4XAu/ud1rz1zZfod72TvIe4GPAucDfBN4KfLQ53fbWik0ryBll1QRNQFU93/w9AvwunQ/ubywO8zZ/j6xdDVtrUBvb91dBVX2j+QfzBPBrvJaqY3tPSJI30Lnh/nRVfa45bD9fJf3a234+HVX1IvAInflQZ6SzchOc3K5jr+yk/rrae2uTqllV9W3g17GPa4KmFeSMsmqCVijJ6UnevPgY+LvAVzl5RYrrgQfWpoatNqiNdwI/1qwUcxHw0mK6j5avJzf7H9Lp59Bp72ublZA205m0+ofTrt+8a+Ya3Ak8WVW/3PWU/XwVDGpv+/nqSbIpyRnN4+8ELqczF+phOis3wev7+FgrO+k1A9r7j7q+NAmd+U/dfdzPFK3IVH4MtKqOJ1lcNWEDcFdV7ZvGtdeZdwC/28yFPBX4rar6QpLdwH1JbgCeBT6whnWce0k+A1wCbExyCPg48Iv0b+NdwJV0JgZ/C/jQ1Cs85wa09yXNUqMFPAP8c4BmNZb7gP10Vqy6sar+ci3qPecuBj4IfKXJoQf4Oeznq2VQe19nP181ZwL3NKvSnUJnNafPJ9kP3Jvk3wGP0wk+af7+ZrOy0zfpfFmr0Q1q799PsolOetoTwL9ozvczRSsWv4iQJEmS1CZT+zFQSZIkSZoGgxxJkiRJrWKQI0mSJKlVDHIkSZIktYpBjiRJkqRWMciRJEmS1CoGOZIkSZJa5f8DL+rH19igU4QAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "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": [ "Writing output to c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_shock-bubble_0008.nc\n", "Opening c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_shock-bubble_0008.nc\n", "Keyword arguments: {'mode': 'w', 'clobber': False}\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Constructed in 1.9076669216156006 seconds\n", "Simulating to t=0.500000. Estimated 1699 timesteps (dt=0.000294)\n", "0% [######################========] 100%. Total: 13s, elapsed: 10s, remaining: 3s\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Closing c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_shock-bubble_0008.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": [ "Writing output to c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_shock-bubble_0008.nc\n", "Opening c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_shock-bubble_0008.nc\n", "Arguments: ('r',)\n", "Animation.save using \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_shock-bubble_0008.nc created Fri Nov 9 10:30:18 2018 contains 21 timesteps\n", "Simulator arguments: \n", " {'rho': '[...]', 'rho_u': '[...]', 'rho_v': '[...]', 'E': '[...]', 'nx': 800, 'ny': 200, 'dx': 0.005, 'dy': 0.005, 'dt': 0.0002942810861169262, 'g': 0.0, 'gamma': 1.4, 'boundary_conditions': '[north=Type.Reflective, south=Type.Reflective, east=Type.Periodic, west=Type.Periodic]', 'context': 'CudaContext id 346033291232'}\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 c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_shock-bubble_0008.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": "iVBORw0KGgoAAAANSUhEUgAAAzkAAADhCAYAAADrl3vGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAF6NJREFUeJzt3X+w5XV93/HniwVC+BVcQLouWKjZiMYKmg3S0qYISRZpJ5ApttCMUobMNlNMtTEt6ExLO2lndNJIkmmU2QpZzBiQIimUoVKGaKmTCC648mujbMGBDVtXfonViuy97/5xvmuvyz2/zz3n3O8+HzPfOfec7+f7+X7uZz+c3Tefz+f9TVUhSZIkSW1x0KwbIEmSJEmTZJAjSZIkqVUMciRJkiS1ikGOJEmSpFYxyJEkSZLUKgY5kiRJklrFIEeSJEnSTCQ5Kcnnk+xI8miS9y9TJkl+P8nOJA8leXu/eg9emeZKkiRJUl97gQ9W1YNJjgIeSHJ3VT22pMy7gA3N8Q7gE81rV87kSJIkSZqJqtpdVQ82P38H2AGs36/YBcCnquNLwDFJ1vWq15kcSZIkSUPb9M4j6rnnF3qWeeChlx8Fvr/koy1VtWW5sklOBt4G3LffqfXA00ve72o+293tvgY5kiRJkob23PML3H/X63uWWbPu8e9X1cZ+dSU5Evgs8IGqemn/08tcUr3qM8iRJEmSNLSieKX2jl1PkkPoBDifrqpblymyCzhpyfsTgWd61TnWnpwk5yX5WpPp4Kpx6pIkSZK0ehSwSPU8+kkS4DpgR1V9rEux24H3NlnWzgS+XVVdl6rBGDM5SdYAfwD8Ap3o6stJbt8vE4IkSZKkllpkcdwqzgLeAzycZHvz2YeB1wNU1bXAncD5wE7ge8Bl/SodZ7naGcDOqnoCIMlNdDIfGORIkiRJLddZrjZekFNVX2T5PTdLyxRwxTD1jhPkLJfl4FX5qpNsBjYDHHF4fubUnzx0jFtKkiRJGsc3nn6FZ59f6BlYDKKAhQGWpM3COEHOQFkOmhRxWwA2nnZY3X/XSa+6SJIkSdJ0nLHp6f6FBjTIvptZGCfIGTrLgSRJkqR2KOCVms8gZ5zsal8GNiQ5JcmhwMV0Mh9IkiRJarmiWOhzzMrIMzlVtTfJ+4C7gDXA9VX16MRaJkmSJGl+FSzM50TOeA8Drao76aR0kyRJknQA6TwnZz6NFeRIkiRJOjAV4ZUaO0nbijDIkSRJkjSShd6PuJkZgxxJkiRJQ+s8J8cgR5IkSVJLdFJIj5OseeUY5EiSJEkaWhEWxnoizcoxyJEkSZI0kkUTD0iSJElqiyL8oNbMuhnLMsiRJEmSNLTOc3JcriZJkiSpRcyuJkmSJKk1qsIrLleTJEmS1Bad5+S4XE2SJElSa4QFn5MjSZIkqS1MPCBJkiSpVUwhLUmSJKl1Fl2uJkmSJKktTDwgSZIkqVUKU0hLkiRJapEqzK4mSZIkqU3CIpl1I5ZlkCNJkiRpaAX8oOYznJjPVkmSJEmaa0VYLGdyJEmSJLWI2dUkSZIktYbZ1SRJkiS1SjG/DwOdz1ZJkiRJmnsLpOcxiCTXJ9mT5JEu538iyX9N8tUkjya5rF+dBjmSJEmShlYVFuugnseAtgLn9Th/BfBYVZ0GnA38TpJDe1XocjVJkiRJQyuYyJ6cqro3ycl9bnVUkgBHAs8De3vVaZAjSZIkaQRhof9szXFJti15v6Wqtgx5o/8I3A48AxwF/MOqWux1Qd8gJ8lJwKeAvwIsNg37vSRrgc8AJwPfAP5BVb0wZIMlSZIkrUKdxAN99908W1Ubx7zVJmA7cA7wBuDuJP+zql7qdsEgC+X2Ah+sqjcBZwJXJHkzcBVwT1VtAO5p3kuSJEk6AOxLId3rmJDLgFurYyfwJHBqrwv6BjlVtbuqHmx+/g6wA1gPXADc0BS7AbhwjIZLkiRJWmUWOajnMSFPAecCJDkBeCPwRK8LhtqT02wIehtwH3BCVe2GTiCU5LXDt1eSJEnSalQFC/2Xq/WV5EY6WdOOS7ILuBo4pHOPuhb4LWBrkoeBAFdW1bO96hw4yElyJPBZ4ANV9VInucFA120GNgO8fr15DiRJkqQ2KMLexYlkV7ukz/lngF8cps6B5pCSHEInwPl0Vd3afPzNJOua8+uAPV0ataWqNlbVxuOPndi6PEmSJEkzNomHga6EvkFOk4/6OmBHVX1syanbgUubny8Fbpt88yRJkiTNo33Z1XodszLI+rGzgPcADyfZ3nz2YeAjwM1JLqezGejdK9NESZIkSfMn7J1cBrWJ6hvkVNUXoetc07mTbY4kSZKk1WBSiQdWgpkAJEmSJI1ksSaWJnqiDHIkSZIkDa2Y7b6bXqYa5Hz9ocPZ9LrTp3lLTcldz2zvX6iLeRgT47S/l3n43Q4Uo/wZrtSfzzy1RbM3zHhwHKz+v09GMejvvFp/v5Uyib+757lPJ/1vk6W/69fruYnUWcBeZ3IkSZIktcm8LldLVU3tZkdnbb0j5iqQJEmSZuW+uoeX6vmx15mtPfW1de71f79nmVvOuvaBqto47r2G5UyOJEmSpKG5XE2SJElSq+x7GOg8MsiRJEmSNBKDHEmSJEmtUcTlapIkSZJapJzJkSRJktQi7smRJEmS1CpF2LvocjVJkiRJLVLO5EiSJElqk0UMciRJkiS1RJl4QJIkSVK7hAX35EiSJElqE/fkSJIkSWoNU0hLkiRJapeCBYMcSZIkSW1RuFxNkiRJUqvE5WqSJEmS2mVx0SBHkiRJUktUuVxNkiRJUsu4XE2SJElSq7hcTZIkSVJrFJnb5WoHzboBkiRJklan6nMMIsn1SfYkeaRHmbOTbE/yaJL/0a9OgxxJkiRJw2sSD/Q6BrQVOK/bySTHAB8Hfqmqfhp4d78KBw5ykqxJ8pUkdzTvT0lyX5LHk3wmyaGD1iVJkiRp9avF9DwGqqPqXuD5HkX+EXBrVT3VlN/Tr85hZnLeD+xY8v6jwDVVtQF4Abh8iLokSZIkrXKdNNLdjwn5KeA1Sb6Q5IEk7+13wUBBTpITgb8LfLJ5H+Ac4JamyA3AhSM1WZIkSdKqUwy0XO24JNuWHJtHuNXBwM/QiUc2Af8qyU/1u2AQvwv8S+Co5v2xwItVtbd5vwtYP3RzJUmSJK1OxSBL0p6tqo1j3mlXU893ge8muRc4Dfh6twv6zuQk+XvAnqp6YOnHyxRddkIqyeZ9kdsrvNzvdpIkSZJWi0mkV+vvNuBvJzk4yeHAO/jRbTSvMshMzlnALyU5HzgMOJrOzM4xSQ5uZnNOBJ5Z7uKq2gJsATg6ayf3q0qSJEmaock8JyfJjcDZdJa27QKuBg4BqKprq2pHks8BDwGLwCerqmu6aRggyKmqDwEfahpwNvCbVfUrSf4zcBFwE3ApnQhLkiRJ0oFgsOVq/aupumSAMr8N/PagdY7znJwrgd9IspPOHp3rxqhLkiRJ0mozneVqQxs08QAAVfUF4AvNz08AZ0y+SZIkSZJWh/FnclbCUEGOJEmSJP3Q4qwbsDyDHEmSJEnDK2ACiQdWgkGOJEmSpJHUnOZONsiRJEmSNJoJZFdbCQY5kiRJkkYSZ3IkSZIktcaM00T3YpAjSZIkaQQx8YAkSZKkljGFtCRJkqRWcbmaJEmSpNbwOTmSJEmS2iZzulztoFk3QJIkSZImyZkcSZIkSSPxOTmSJEmS2qOARffkSJIkSWoTZ3IkSZIktYnL1SRJkiS1y5xmVzPIkSRJkjS0lDM5kiRJktrGh4FKkiRJahVnciRJkiS1SdyTI0mSJKk13JMjSZIkqXUMciRJkiS1ybwuVzto1g2QJEmSpElyJkeSJEnSaFyuJkmSJKk1an6XqxnkSJIkSRrNnM7kDLQnJ8kxSW5J8hdJdiT5G0nWJrk7yePN62tWurGSJEmS5kPopJDudczKoIkHfg/4XFWdCpwG7ACuAu6pqg3APc17SZIkSQeCZrlar2MQSa5PsifJI33K/WyShSQX9auzb5CT5Gjg54DrAKrqB1X1InABcENT7Abgwn51SZIkSWqR6nMMZitwXq8CSdYAHwXuGqTCQWZy/hrwLeAPk3wlySeTHAGcUFW7AZrX1w5yQ0mSJEktMYEgp6ruBZ7vU+zXgc8Cewapc5Ag52Dg7cAnquptwHcZYmlaks1JtiXZ9govD3qZJEmSpDk3wJ6c4/bFAs2xeeh7JOuBXwauHfSaQbKr7QJ2VdV9zftb6AQ530yyrqp2J1lHl6iqqrYAWwCOzto5zb8gSZIkaSgF9N9382xVbRzzTr8LXFlVC0kGuqBvkFNV/zvJ00neWFVfA84FHmuOS4GPNK+3jdxsSZIkSavOlDKobQRuagKc44Dzk+ytqv/S7YJBn5Pz68CnkxwKPAFcRmep281JLgeeAt49TsslSZIkrTJTCHKq6pR9PyfZCtzRK8CBAYOcqtpOJ4La37nDNFCSJElSewyaJrpnHcmNwNl09u/sAq4GDgGoqoH34Sw16EyOJEmSJP1/w6WJ7l5N1SVDlP3Hg5QzyJEkSZI0tDTHPDLIkSRJkjSSSSxXWwkGOZIkSZJGM6cPiDHIkSRJkjQagxxJkiRJrVEuV5MkSZLUMlN6GOjQDHIkSZIkjcYgR5IkSVKbOJMjSZIkqT0KcE+OJEmSpLYIzuRIkiRJahuDHEmSJEmtUZDF+YxyDHIkSZIkjcTlapIkSZLaxSBHkiRJUpvE7GqSJEmSWqNcriZJkiSpbQxyJEmSJLVFMLuaJEmSpJZxudqcuOuZ7WPXsel1p0+gJe2yXL/Oup8m8We9lL/P6tCrn9r2O48yJtrWB1qdDqT/TjU7k/57c59ZjtFJ/U5nbPreROqhmNvlaqmaXss2nnZY3X/XSVO7nyRJkqQfdcamp9n21e9n3HqOXHtSvfUXPtCzzJ/f/JsPVNXGce81rANuJkeSJEnSZJhCWpIkSVJ7FDDFVWHDMMiRJEmSNBITD0iSJElqjU4K6Vm3YnkGOZIkSZKGV+VyNUmSJEnt4nI1SZIkSa0yr8vVDhqkUJJ/nuTRJI8kuTHJYUlOSXJfkseTfCbJoSvdWEmSJElzooDF6n3MSN8gJ8l64J8BG6vqLcAa4GLgo8A1VbUBeAG4fCUbKkmSJGnOVJ9jRgaayaGzrO3HkxwMHA7sBs4BbmnO3wBcOPnmSZIkSZpXWayex0B1JNcn2ZPkkS7nfyXJQ83xZ0lO61dn3yCnqv4S+A/AU3SCm28DDwAvVtXeptguYH2XRm1Osi3Jtm89t9DvdpIkSZJWiVTvY0BbgfN6nH8S+DtV9Vbgt4At/SocZLnaa4ALgFOA1wFHAO9apuiyv0ZVbamqjVW18fhj1/S7nSRJkqTVoN9StQGDnKq6F3i+x/k/q6oXmrdfAk7sV+cg2dV+Hniyqr4FkORW4G8CxyQ5uJnNORF4ZoC6JEmSJLVAgPR/Ts5xSbYteb+lqvrOxPRwOfDf+hUaJMh5CjgzyeHA/wXOBbYBnwcuAm4CLgVuG7mpkiRJkladLPQNcp6tqo0TuVfyTjpBzt/qV3aQPTn30Ukw8CDwcHPNFuBK4DeS7ASOBa4bo82SJEmSVpMJLVcbRJK3Ap8ELqiq5/qVH+hhoFV1NXD1fh8/AZwxdAslSZIktUBB/+VqY0vyeuBW4D1V9fVBrhkoyJEkSZKk/Q2aJrpnHcmNwNl09u/sojO5cghAVV0L/Gs6K8c+ngRgb78lcAY5kiRJkoZXkMUJVFN1SZ/zvwr86jB1GuRIkiRJGs0UlquNwiBHkiRJ0kgmsVxtJRjkSJIkSRqNMzmSJEmSWqOACezJWQkGOZIkSZKGFooszmeUY5AjSZIkaTQuV5MkSZLUGi5XkyRJktQ2cSZHkiRJUnsUuCdHkiRJUmsU7smRJEmS1DLzOZFjkCNJkiRpNKaQliRJktQeBSy6XE2SJElSa5R7ciRJkiS1jMvVJEmSJLWGy9UkSZIktUtBOZMjSZIkqS0KWDDIkSRJktQmJh6QJEmS1CoGOZIkSZLawxTSkiRJktqkgIWFWbdiWQY5kiRJkkbjTI4kSZKk9iifkyNJkiSpRQrK5WqSJEmSWsXlapIkSZJaowoWfRioJEmSpBZxuRrwwEMvP7tm3c7vAs9O874HuOOwv6fNPp8++3y67O/ps8+nzz6fLvt7uv7qZKrxOTkAVNXxSbZV1cZp3vdAZn9Pn30+ffb5dNnf02efT599Pl329ypVzG12tYNm3QBJkiRJq0/RWa7W6xhEkuuT7EnySJfzSfL7SXYmeSjJ2/vVaZAjSZIkaXhVUIu9j8FsBc7rcf5dwIbm2Ax8ol+Fswhytszgngcy+3v67PPps8+ny/6ePvt8+uzz6bK/V6larJ7HQHVU3Qs836PIBcCnquNLwDFJ1vWqMzWnm4UkSZIkza8kn6OTNKKXw4DvL3m/papeFdQmORm4o6ressy5O4CPVNUXm/f3AFdW1bZuNzWFtCRJkqShVVWvJWaTlOVu3+sC9+RIkiRJmme7gJOWvD8ReKbXBVMLcpKcl+RrTVaEq6Z13wNNkm8keTjJ9iTbms/WJrk7yePN62tm3c7VbLkMIN36eJRsIPpRXfr73yT5y2acb09y/pJzH2r6+2tJNs2m1atbkpOSfD7JjiSPJnl/87njfAX06G/H+QpJcliS+5N8tenzf9t8fkqS+5ox/pkkhzaf/1jzfmdz/uRZtn+16dHfW5M8uWSMn9587neK9nc78N5mbJwJfLuqdve6YCpBTpI1wB/QyYzwZuCSJG+exr0PUO+sqtOX5Ju/CrinqjYA9zTvNbqtvDoDSLc+HjobiF5lK8tnXLmmGeenV9WdAM33ysXATzfXfLz5/tFw9gIfrKo3AWcCVzR96zhfGd36GxznK+Vl4JyqOg04HTiv+YfTR+n0+QbgBeDypvzlwAtV9ZPANU05Da5bfwP8iyVjfHvzmd8pB5gkNwJ/Drwxya4klyf5tSS/1hS5E3gC2An8J+Cf9qtzWjM5ZwA7q+qJqvoBcBOdLAmajguAG5qfbwAunGFbVr0uGUC69fHQ2UD0owbIuLLUBcBNVfVyVT1J58vwjBVrXEtV1e6qerD5+TvADmA9jvMV0aO/u3Gcj6kZq/+neXtIcxRwDnBL8/n+Y3zf2L8FODfJcnsEtIwe/d2N3ykHmKq6pKrWVdUhVXViVV1XVddW1bXN+aqqK6rqDVX113slHNhnWkHOeuDpJe930fsLXKMr4L8neSDJ5uazE/ZN6TWvr51Z69qrWx879lfO+5plDNcvWYJpf09YsyznbcB9OM5X3H79DY7zFZNkTZLtwB7gbuB/AS9W1d6myNJ+/WGfN+e/DRw73Ravbvv3d1XtG+P/vhnj1yT5seYzx7jGNq0gZ+iMCBrZWVX1djpTvVck+blZN+gA59hfGZ8A3kBn2cNu4Heaz+3vCUpyJPBZ4ANV9VKvost8Zr8PaZn+dpyvoKpaqKrT6WxgPgN403LFmlf7fEz793eStwAfAk4FfhZYC1zZFLe/NbZpBTlDZ0TQaKrqmeZ1D/AndL64v7lvmrd53TO7FrZWtz527K+Aqvpm8xfmIp21ufuW6tjfE5LkEDr/4P50Vd3afOw4XyHL9bfjfDqq6kXgC3T2Qx2TZN/jNZb26w/7vDn/Ewy+jFZLLOnv85qlmlVVLwN/iGNcEzStIOfLwIYma8mhdDZM3j6lex8wkhyR5Kh9PwO/CDxCp68vbYpdCtw2mxa2Wrc+HjobiPrbb232L9MZ59Dp74ubTEin0Nm0ev+027faNXsNrgN2VNXHlpxynK+Abv3tOF85SY5Pckzz848DP09nL9TngYuaYvuP8X1j/yLgT8unqQ+sS3//xZL/aRI6+5+WjnG/UzSWqTwMtKr2JnkfcBewBri+qh6dxr0PMCcAf9LshTwY+OOq+lySLwM3J7kceAp49wzbuOo1GUDOBo5Lsgu4GvgIy/fxncD5dDYGfw+4bOoNXuW69PfZTarRAr4B/BOAqno0yc3AY3QyVl1RVQuzaPcqdxbwHuDhZg09wIdxnK+Ubv19ieN8xawDbmiy0h0E3FxVdyR5DLgpyb8DvkIn+KR5/aMkO+nM4Fw8i0avYt36+0+THE9nedp2YGkmLb9TNJb4PyIkSZIktcnUHgYqSZIkSdNgkCNJkiSpVQxyJEmSJLWKQY4kSZKkVjHIkSRJktQqBjmSJEmSWsUgR5IkSVKr/D8drCPSurrWzQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": {}, "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": [ "Writing output to c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_kelvin_helmholtz_0004.nc\n", "Opening c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_kelvin_helmholtz_0004.nc\n", "Keyword arguments: {'mode': 'w', 'clobber': False}\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Constructed in 0.00900578498840332 seconds\n", "Simulating to t=10.000000. Estimated 8998 timesteps (dt=0.001111)\n", "0% [############==================] 100%. Total: 25s, elapsed: 10s, remaining: 15s\n", "0% [#######################=======] 100%. Total: 26s, elapsed: 20s, remaining: 5s\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Closing c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_kelvin_helmholtz_0004.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": [ "Writing output to c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_kelvin_helmholtz_0004.nc\n", "Opening c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_kelvin_helmholtz_0004.nc\n", "Arguments: ('r',)\n", "Animation.save using \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_kelvin_helmholtz_0004.nc created Fri Nov 9 10:30:36 2018 contains 101 timesteps\n", "Simulator arguments: \n", " {'rho': '[...]', 'rho_u': '[...]', 'rho_v': '[...]', 'E': '[...]', 'nx': 400, 'ny': 200, 'dx': 0.005, 'dy': 0.005, 'dt': 0.001111278446818193, 'g': 0.0, 'gamma': 1.4, 'boundary_conditions': '[north=Type.Periodic, south=Type.Periodic, east=Type.Periodic, west=Type.Periodic]', 'context': 'CudaContext id 346033291232'}\n", "0% [########======================] 100%. Total: 19s, elapsed: 5s, remaining: 13s\n", "0% [################==============] 100%. Total: 19s, elapsed: 10s, remaining: 9s\n", "0% [########################======] 100%. Total: 19s, elapsed: 15s, remaining: 3s\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 c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_kelvin_helmholtz_0004.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": {}, "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": [ "Writing output to c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_rayleigh-taylor_0002.nc\n", "Opening c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_rayleigh-taylor_0002.nc\n", "Keyword arguments: {'mode': 'w', 'clobber': False}\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Constructed in 0.01562356948852539 seconds\n", "Simulating to t=30.000000. Estimated 30697 timesteps (dt=0.000977)\n", "0% [####==========================] 100%. Total: 1m 26s, elapsed: 10s, remaining: 1m 16s\n", "0% [#######=======================] 100%. Total: 1m 26s, elapsed: 20s, remaining: 1m 6s\n", "0% [##########====================] 100%. Total: 1m 26s, elapsed: 30s, remaining: 56s\n", "0% [##############================] 100%. Total: 1m 27s, elapsed: 40s, remaining: 46s\n", "0% [#################=============] 100%. Total: 1m 27s, elapsed: 50s, remaining: 37s\n", "0% [#####################=========] 100%. Total: 1m 27s, elapsed: 1m, remaining: 27s\n", "0% [########################======] 100%. Total: 1m 28s, elapsed: 1m 10s, remaining: 17s\n", "0% [############################==] 100%. Total: 1m 28s, elapsed: 1m 20s, remaining: 7s\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Closing c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_rayleigh-taylor_0002.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": [ "Writing output to c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_rayleigh-taylor_0002.nc\n", "Opening c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_rayleigh-taylor_0002.nc\n", "Arguments: ('r',)\n", "Animation.save using \n", "figure size (inches) has been adjusted from 3.4 x 8.0 to 3.388888888888889 x 8.0\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_rayleigh-taylor_0002.nc created Fri Nov 9 10:31:24 2018 contains 301 timesteps\n", "Simulator arguments: \n", " {'rho': '[...]', 'rho_u': '[...]', 'rho_v': '[...]', 'E': '[...]', 'nx': 151, 'ny': 453, 'dx': 0.0033112582781456954, 'dy': 0.0033112582781456954, 'dt': 0.0009772880151828723, 'g': 0.1, 'gamma': 1.4, 'boundary_conditions': '[north=Type.Reflective, south=Type.Reflective, east=Type.Reflective, west=Type.Reflective]', 'context': 'CudaContext id 346033291232'}\n", "0% [########======================] 100%. Total: 19s, elapsed: 5s, remaining: 14s\n", "0% [##############================] 100%. Total: 21s, elapsed: 10s, remaining: 11s\n", "0% [#####################=========] 100%. Total: 22s, elapsed: 15s, remaining: 7s\n", "0% [###########################===] 100%. Total: 22s, elapsed: 20s, remaining: 2s\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 c:\\Users\\anbro\\Documents\\projects\\GPUSimulators\\data\\euler_rayleigh-taylor_0002.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 [conda env:anaconda3]", "language": "python", "name": "conda-env-anaconda3-py" }, "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.6.7" } }, "nbformat": 4, "nbformat_minor": 2 }