storm2d_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load modules:\n",
    "from boutdata.data import BoutOutputs, BoutOptionsFile # container class for outputs collected from BOUT.dmp.* files\n",
    "from boututils.showdata import showdata # function that produces matplotlib animations\n",
    "import numpy\n",
    "import matplotlib\n",
    "from matplotlib import pyplot\n",
    "from IPython.display import HTML\n",
    "\n",
    "# Output is 2d with one point in the y-direction\n",
    "# Slicing with these indices eliminates the y-dimension from the arrays\n",
    "inds = numpy.index_exp[:,:,0,:]\n",
    "\n",
    "# path to directory with simulation output\n",
    "path = '.'\n",
    "\n",
    "# fraction of amplitude above background to use as minimum when finding centre-of-mass\n",
    "threshold = 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make matplotlib plots interactive\n",
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# container object for BOUT++ simulation output\n",
    "data = BoutOutputs(path=path, xguards=False, caching=True)\n",
    "\n",
    "# grid sizes\n",
    "nt, nx, nz = data['n'][inds].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# object to interact with options from BOUT++ input file\n",
    "\n",
    "#options = BoutOptionsFile(path+'/BOUT.inp') # read input file\n",
    "\n",
    "# BOUT.settings file contains options actually used by the simulation, including command line options and defaults\n",
    "options = BoutOptionsFile(path+'/BOUT.settings')\n",
    "\n",
    "# get some parameters\n",
    "A = max(options['blob']['A'], options['blob2']['A']) # amplitude of the largest filament\n",
    "Lx = options['mesh']['Lx'] # radial width of domain, in units of rho_s\n",
    "Lz = options['mesh']['Lz'] # binormal width of domain, in units of rho_s\n",
    "\n",
    "# x-coordinate in units of rho_s\n",
    "# make coordinates 2d arrays so that they broadcast correctly with data arrays\n",
    "x = numpy.linspace(0.5/nx*Lx, Lx*(1.-0.5/nx), nx)[:, numpy.newaxis]\n",
    "\n",
    "# z-coordinate in units of rho_s\n",
    "z = numpy.linspace(0., Lz, nz, endpoint=False)[numpy.newaxis, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# make a movie of the density\n",
    "# there is extra code to make the movie be inserted inline in the Jupyter notebook\n",
    "# in a python script/interpreter, this would just be showdata(data['n'][inds], t_array=data['t_array'], x=x[:,0], y=z[0,:])\n",
    "HTML(showdata(data['n'][inds], t_array=data['t_array'], x=x[:,0], y=z[0,:], return_animation=True).to_jshtml())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find the centre-of-mass position of the filaments\n",
    "\n",
    "# take 'filament' to be the density above this level\n",
    "nmin = 1. + threshold*A\n",
    "\n",
    "nFilament = data['n'][inds] - nmin\n",
    "# zero all negative entries, which represent density below the threshold\n",
    "nFilament[nFilament<0.] = 0.\n",
    "\n",
    "# calculate centre-of-mass\n",
    "# sum over x- and z-dimensions\n",
    "# don't need area element dx*dz because we only want ratios of integrals\n",
    "nTotal = numpy.sum(nFilament, axis=(1,2))\n",
    "xCoM = numpy.sum(x*nFilament, axis=(1,2))/nTotal\n",
    "zCoM = numpy.sum(z*nFilament, axis=(1,2))/nTotal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find the centre-of-mass velocity\n",
    "\n",
    "dt = data['t_array'][1] - data['t_array'][0]\n",
    "\n",
    "# will take simple finite-difference time derivative with output half way between data time points\n",
    "tArrayVelocity = 0.5*(data['t_array'][:-1] + data['t_array'][1:])\n",
    "\n",
    "# calculate velocities\n",
    "vxCoM = 0.5 * (xCoM[1:] - xCoM[:-1]) / dt\n",
    "vzCoM = 0.5 * (zCoM[1:] - zCoM[:-1]) / dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot centre-of-mass positions\n",
    "pyplot.figure()\n",
    "pyplot.plot(data['t_array'], xCoM)\n",
    "pyplot.xlabel('t / Omega_i^-1')\n",
    "pyplot.ylabel('xCoM / rho_s')\n",
    "\n",
    "pyplot.figure()\n",
    "pyplot.plot(data['t_array'], zCoM)\n",
    "pyplot.xlabel('t / Omega_i^-1')\n",
    "pyplot.ylabel('zCoM / rho_s')\n",
    "\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot centre-of-mass velocities\n",
    "pyplot.figure()\n",
    "pyplot.plot(tArrayVelocity, vxCoM)\n",
    "pyplot.xlabel('t / Omega_i^-1')\n",
    "pyplot.ylabel('vxCoM / c_s')\n",
    "\n",
    "pyplot.figure()\n",
    "pyplot.plot(tArrayVelocity, vzCoM)\n",
    "pyplot.xlabel('t / Omega_i^-1')\n",
    "pyplot.ylabel('vzCoM / c_s')\n",
    "\n",
    "pyplot.show()"
   ]
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}