{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# tov_ET\n", "\n", "This notebook demonstrates how to read and work with data from the tov_ET simulation generated with the Einstein Toolkit code. \n", "\n", "See: [Cactus tutorial](https://github.com/nds-org/jupyter-et/blob/master/tutorial-server/notebooks/CactusTutorial.ipynb)\n", "\n", "Aurel reads in 3D data so update the tov_ET.par file accordingly, see below." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "import aurel" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setting things up\n", "\n", "First you need to tell aurel where you store your simulations directory. You can run the following in the notebook, but update the path to your own." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import os\n", "os.environ[\"SIMLOC\"] = \"/Users/rlm36AA/simulations/\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Alternatively, in your bashrc include:\n", "\n", "`export SIMLOC=\"/path/to/simulations/\"`\n", "\n", "then after reloading the terminal, you can check this with\n", "\n", "`echo $SIMLOC`" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4th order finite difference schemes are defined\n" ] } ], "source": [ "# Create a dictionary with the content of the simulation's parameter file\n", "param = aurel.parameters('tov_ET_group_one')\n", "# Define the FiniteDifference class for the base level grid of the simulation\n", "fd = aurel.FiniteDifference(param)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "aurel.read_data and aurel.AurelCore only work on 3D data, so add the following to the tov_ET.par before running the simulation:\n", "\n", "CarpetIOHDF5::out_every = 4096\n", "\n", "CarpetIOHDF5::out_vars = \"\n", "\n", " HydroBase::rho \n", "\n", " ...and any other relevant variables\n", "\n", "\"" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Reading iterations in /Users/rlm36AA/simulations/tov_ET_group_one/iterations.txt\n", " === restart 0\n", "3D variables available: ['gammadown3', 'Kdown3', 'Ktrace', 'alpha', 'dtalpha', 'betaup3', 'dtbetaup3', 'rho0', 'eps', 'press', 'w_lorentz', 'velup3', 'Hamiltonian', 'Momentumup3', 'Weyl_Psi']\n", "it = 0 -> 409600\n", "rl = 0 at it = np.arange(0, 409600, 4096)\n", "rl = 1 at it = np.arange(0, 409600, 4096)\n", "\n", "Restarts to process: []\n", " === Overall iterations\n", "rl = 0 at it = np.arange(0, 409600, 4096)\n", "rl = 1 at it = np.arange(0, 409600, 4096)\n", "\n", " == For info\n", "it_dict : {0: {'var available': ['gammadown3', 'Kdown3', 'Ktrace', 'alpha', 'dtalpha', 'betaup3', 'dtbetaup3', 'rho0', 'eps', 'press', 'w_lorentz', 'velup3', 'Hamiltonian', 'Momentumup3', 'Weyl_Psi'], 'its available': [0, 409600], 'rl = 0': [0, 409600, 4096], 'rl = 1': [0, 409600, 4096]}, 'overall': {'rl = 0': [[0, 409600, 4096]], 'rl = 1': [[0, 409600, 4096]]}}\n", "content : {('dtalp',): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/admbase-dtlapse.h5'], ('gxx', 'gxy', 'gxz', 'gyy', 'gyz', 'gzz'): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/admbase-metric.h5'], ('rho',): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/hydrobase-rho.h5'], ('trK',): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/ml_bssn-ml_trace_curv.h5'], ('eps',): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/hydrobase-eps.h5'], ('Psi4i',): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/weylscal4-psi4i_group.h5'], ('alp',): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/admbase-lapse.h5'], ('Psi4r',): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/weylscal4-psi4r_group.h5'], ('betax', 'betay', 'betaz'): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/admbase-shift.h5'], ('H',): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/ml_bssn-ml_ham.h5'], ('kxx', 'kxy', 'kxz', 'kyy', 'kyz', 'kzz'): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/admbase-curv.h5'], ('M1', 'M2', 'M3'): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/ml_bssn-ml_mom.h5'], ('w_lorentz',): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/hydrobase-w_lorentz.h5'], ('vel[0]', 'vel[1]', 'vel[2]'): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/hydrobase-vel.h5'], ('press',): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/hydrobase-press.h5'], ('dtbetax', 'dtbetay', 'dtbetaz'): ['/Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/admbase-dtshift.h5']}\n" ] } ], "source": [ "# This lists all the iterations available accross different refinement levels and restarts\n", "it_dict = aurel.iterations(param, skip_last = False)\n", "# By default skip_last = True so that the last restart is skipped to avoid reading active files\n", "# This is all nicely written in a human readable file called 'iterations.txt'\n", "# But also provided as a dictionary\n", "\n", "print()\n", "print(' == For info')\n", "print('it_dict :', it_dict)\n", "# And a 'content.txt' file was also created\n", "# This lists the available variables and what files they are in\n", "content = aurel.get_content(param, verbose=False)\n", "print('content :', content)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Reading in the data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Great, we can choose a couple of iterations and read in the simulation data" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Reading iterations in /Users/rlm36AA/simulations/tov_ET_group_one/iterations.txt\n", "Restarts to process: []\n", "Nothing new to process. Consider running with skip_last=False to analyse the last restart (if it is not an active restart).\n", "Loading existing content from /Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/content.txt...\n", "Loaded 16 variables from cache.\n", " =========== Restart 0:\n", "vars to get ['gammadown3', 'Kdown3', 'Ktrace', 'alpha', 'dtalpha', 'betaup3', 'dtbetaup3', 'rho0', 'eps', 'press', 'w_lorentz', 'velup3', 'Hamiltonian', 'Momentumup3', 'Weyl_Psi']:\n", "Data read from split iterations: ['kxy', 'Hamiltonian', 'betax', 'Ktrace', 'dtbetay', 'Momentumz', 'kyy', 'kyz', 'gxy', 'Weyl_Psi4i', 'gzz', 'gxx', 'kzz', 'Weyl_Psi4r', 'gyy', 'Momentumy', 'gyz', 'vely', 'eps', 'alpha', 'dtalpha', 'dtbetaz', 'press', 'rho0', 'kxx', 'betay', 'Momentumx', 'gxz', 'velz', 'velx', 'kxz', 'betaz', 'w_lorentz', 'dtbetax', 't']\n", "\n", " == Data read from the simulation:\n", "dict_keys(['it', 'kxy', 'Hamiltonian', 'betax', 'Ktrace', 'dtbetay', 'Momentumz', 'kyy', 'kyz', 'gxy', 'Weyl_Psi4i', 'gzz', 'gxx', 'kzz', 'Weyl_Psi4r', 'gyy', 'Momentumy', 'gyz', 'vely', 'eps', 'alpha', 'dtalpha', 'dtbetaz', 'press', 'rho0', 'kxx', 'betay', 'Momentumx', 'gxz', 'velz', 'velx', 'kxz', 'betaz', 'w_lorentz', 'dtbetax', 't'])\n", "it format: type and shape (100,)\n", "rho0 format: type and shape (100, 12, 12, 12)\n", "rho0[0] format: type and shape (12, 12, 12)\n" ] } ], "source": [ "data = aurel.read_data(\n", " param, \n", " vars = [],\n", " # Specify the fields to read, these have to be 3D outputs of the simulation amongst the available variables listed above\n", " # e.g. ['gammadown3', 'rho0', 'Weyl_Psi']\n", " # If var is empty, all available variables will be read\n", " it = np.arange(0, 409600, 4096), # Iterations to be read, default is [0]\n", " rl = 0, # Refinement level default is 0\n", " restart = 0, # Restart number, default is -1, meaning it'll find the restart of the iteration you want\n", " split_per_it=True, # This will copy the data in per-iteration files for easier access next time and to facilitate parallel reading\n", " verbose=True,\n", " veryverbose=False)\n", "\n", "# The output is a dictionary with the iteration, simulation time, and each requested variables\n", "print()\n", "print(' == Data read from the simulation:')\n", "print(data.keys())\n", "print('it format: type {} and shape {}'.format(type(data['it']), np.shape(data['it'])))\n", "print('rho0 format: type {} and shape {}'.format(type(data['rho0']), np.shape(data['rho0'])))\n", "print('rho0[0] format: type {} and shape {}'.format(type(data['rho0'][0]), np.shape(data['rho0'][0])))\n", "# note some variable names may be different to those called\n", "# the new names will match the AurelCore naming convention\n", "# rho0: rest-mass energy density" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This data can directly be assessed and plotted" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing it = 0\n", "Processing estimation item: max\n", "Now processing remaining time steps sequentially\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6654a239a4ab4134a88692c7a13d979d", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/99 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(15, 6))\n", "\n", "# plot the first iteration\n", "it_index = 0 # iteration index\n", "iz = 0 # z slice index\n", "plt.subplot(121)\n", "plt.pcolor(fd.xarray, fd.yarray, data['rho0'][it_index][:,:,iz])\n", "plt.colorbar()\n", "plt.title(r'$\\rho_0$ at $t=0$ and $z=0$')\n", "plt.xlabel(r'$x$')\n", "plt.ylabel(r'$y$')\n", "\n", "# get the maximum rest mass density at each iteration\n", "data = aurel.over_time(data, fd, estimates=['max'])\n", "\n", "# plot the maximum rest mass density as a function of time\n", "plt.subplot(122)\n", "plt.plot(data['t'], data['rho0_max'] / data['rho0_max'][0])\n", "plt.grid()\n", "plt.xlabel(r'$t$ [$M_{\\odot}$]')\n", "plt.title(r'$max(\\rho_0) / \\rho_0(0)$')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "How about calculating further terms provided by AurelCore at each time step. \n", "\n", "Well this is all available with the `over_time` function, see the example:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing it = 0\n" ] }, { "data": { "text/latex": [ "Cosmological constant set to AurelCore.Lambda = 0.00e+00" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "Calculated gammadown3: $\\gamma_{ij}$ Spatial metric with spatial indices down" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "Calculated gammadet: $\\gamma$ Determinant of spatial metric" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Processing estimation item: max\n", "Now processing remaining time steps sequentially\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bd7f82ffb72e46ef9df4c5ae07344158", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/99 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# calculating at the determinant of the spatial metric\n", "variable = 'gammadet'\n", "varstr = r'$\\gamma$'\n", "data = aurel.over_time(data, fd, vars=[variable], estimates=['max'])\n", "\n", "plt.figure(figsize=(15, 6))\n", "\n", "# plot the first iteration\n", "plt.subplot(121)\n", "plt.pcolor(fd.xarray, fd.yarray, data[variable][it_index][:,:,0])\n", "plt.colorbar()\n", "plt.title(varstr + r' at $t=0$ and $z=0$')\n", "plt.xlabel(r'$x$')\n", "plt.ylabel(r'$y$')\n", "\n", "# plot the maximum rest mass density as a function of time\n", "plt.subplot(122)\n", "plt.plot(data['t'], data[variable+'_max'])\n", "plt.grid()\n", "plt.xlabel(r'$t$ [$M_{\\odot}$]')\n", "plt.ylabel('max(' + varstr + ')')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Want to work with a refined level?" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Reading iterations in /Users/rlm36AA/simulations/tov_ET_group_one/iterations.txt\n", "Restarts to process: []\n", "Nothing new to process. Consider running with skip_last=False to analyse the last restart (if it is not an active restart).\n", "Loading existing content from /Users/rlm36AA/simulations/tov_ET_group_one/output-0000/tov_ET_group_one/content.txt...\n", "Loaded 16 variables from cache.\n", " =========== Restart 0:\n", "vars to get ['rho0', 'gammadown3']:\n", "Data read from split iterations: ['gxz', 'gzz', 'gxx', 'rho0', 'gyy', 'gyz', 'gxy', 't']\n", "4th order finite difference schemes are defined\n" ] } ], "source": [ "# Delete the previous finitedifference class (or name the new one something else)\n", "del fd\n", "# now we will look at the following refinement level\n", "rl = 1\n", "\n", "# load the data from that level\n", "data = aurel.read_data(\n", " param, \n", " vars=['rho0', 'gammadown3'],\n", " it = np.arange(0, 409600, 4096),\n", " rl = rl, verbose=True)\n", "\n", "# relevant parameters of this grid level\n", "Nx, Ny, Nz = np.shape(data['rho0'][0])\n", "grid = {\n", " 'Nx': Nx, 'Ny': Ny, 'Nz': Nz,\n", " 'xmin': 0.0, 'ymin': 0.0, 'zmin': 0.0,\n", " 'dx': param['dx']/2**rl,\n", " 'dy': param['dx']/2**rl,\n", " 'dz': param['dx']/2**rl,\n", " 'Lx': Nx * param['dx']/2**rl,\n", " 'Ly': Ny * param['dx']/2**rl,\n", " 'Lz': Nz * param['dx']/2**rl,\n", "}\n", "fd = aurel.FiniteDifference(grid)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing it = 0\n" ] }, { "data": { "text/latex": [ "Cosmological constant set to AurelCore.Lambda = 0.00e+00" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "Calculated gammadown3: $\\gamma_{ij}$ Spatial metric with spatial indices down" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/latex": [ "Calculated gammadet: $\\gamma$ Determinant of spatial metric" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Processing estimation item: max\n", "Now processing remaining time steps sequentially\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "11da6ed9bcca4813ac9ba948dab02ba0", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/99 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(15, 6))\n", "\n", "# plot the first iteration\n", "it_index = 0 # iteration index\n", "iz = 0 # z slice index\n", "plt.subplot(121)\n", "plt.pcolor(fd.xarray, fd.yarray, data['rho0'][it_index][:,:,iz])\n", "plt.colorbar()\n", "plt.title(r'$\\rho_0$ at $t=0$ and $z=0$')\n", "plt.xlabel(r'$x$')\n", "plt.ylabel(r'$y$')\n", "\n", "# plot the maximum rest mass density as a function of time\n", "plt.subplot(122)\n", "plt.plot(data['t'], data['rho0_max'] / data['rho0_max'][0])\n", "plt.grid()\n", "plt.xlabel(r'$t$ [$M_{\\odot}$]')\n", "plt.title(r'$max(\\rho_0) / \\rho_0(0)$')" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'max($\\\\gamma$)')" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# calculating at the determinant of the spatial metric\n", "variable = 'gammadet'\n", "varstr = r'$\\gamma$'\n", "\n", "plt.figure(figsize=(15, 6))\n", "it_index = 0\n", "\n", "# plot the first iteration\n", "plt.subplot(121)\n", "plt.pcolor(fd.xarray, fd.yarray, data[variable][it_index][:,:,0])\n", "plt.colorbar()\n", "plt.title(varstr + r' at $t=0$ and $z=0$')\n", "plt.xlabel(r'$x$')\n", "plt.ylabel(r'$y$')\n", "\n", "# plot the maximum rest mass density as a function of time\n", "plt.subplot(122)\n", "plt.plot(data['t'], data[variable+'_max'])\n", "plt.grid()\n", "plt.xlabel(r'$t$ [$M_{\\odot}$]')\n", "plt.ylabel('max(' + varstr + ')')" ] }, { "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.13.7" } }, "nbformat": 4, "nbformat_minor": 2 }