Tutorial-ETK_thorn-WaveToyNRPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<script async src=\"https://www.googletagmanager.com/gtag/js?id=UA-59152712-8\"></script>\n",
    "<script>\n",
    "  window.dataLayer = window.dataLayer || [];\n",
    "  function gtag(){dataLayer.push(arguments);}\n",
    "  gtag('js', new Date());\n",
    "\n",
    "  gtag('config', 'UA-59152712-8');\n",
    "</script>\n",
    "\n",
    "# The Scalar Wave Equation: Creating an Einstein Toolkit thorn\n",
    "\n",
    "## Author: Zach Etienne\n",
    "### Formatting improvements courtesy Brandon Clark\n",
    "\n",
    "[comment]: <> (Abstract: TODO)\n",
    "\n",
    "**Notebook Status:** <font color='green'><b> Validated</b></font> \n",
    "\n",
    "**Validation Notes:** As demonstrated [in the plot below](#code_validation), the numerical error converges to zero at the expected rate.\n",
    "\n",
    "### NRPy+ Source Code for this module: \n",
    "* [ScalarWave/ScalarWave_RHSs.py](../edit/ScalarWave/ScalarWave_RHSs.py) [\\[**tutorial**\\]](Tutorial-ScalarWave.ipynb) \n",
    "* [ScalarWave/InitialData.py](../edit/ScalarWave/InitialData.py) [\\[**tutorial**\\]](Tutorial-ScalarWave.ipynb)\n",
    "\n",
    "## Introduction:\n",
    "This tutorial notebook focuses on how to construct an Einstein Toolkit (ETK) thorn (module) that will set up the expressions for the right-hand sides of $\\partial_t u$ and $\\partial_t v$ for the scalar wave equation, as defined in the [Tutorial-ScalarWave.ipynb](Tutorial-ScalarWave.ipynb) NRPy+ tutorial notebook. In that module, we used NRPy+ to contruct the SymPy expressions for these scalar wave \"time-evolution equations\". This thorn is largely based on and should function similarly to the $\\text{WaveToyC}$ thorn included in the Einstein Toolkit (ETK) $\\text{CactusWave}$ arrangement.\n",
    "\n",
    "When interfaced properly with the ETK, this module will propagate the initial data for $u$ and $v$ defined in [IDScalarWaveNRPy](Tutorial-ETK_thorn-IDScalarWaveNRPy.ipynb) forward in time by integrating the equations for $\\partial_t u$ and $\\partial_t v$ subject to spatial boundary conditions. The time evolution itself is handled by the $\\text{MoL}$ (Method of Lines) thorn in the $\\text{CactusNumerical}$ arrangement, and the boundary conditions by the $\\text{Boundary}$ thorn in the $\\text{CactusBase}$ arrangement. \n",
    "\n",
    "Similar to the [IDScalarWaveNRPy](Tutorial-ETK_thorn-IDScalarWaveNRPy.ipynb) module, we will construct the WaveToyNRPy module in two steps.\n",
    "\n",
    "1. Call on NRPy+ to convert the SymPy expressions for the evolution equations into one C-code kernel.\n",
    "1. Write the C code and linkages to the Einstein Toolkit infrastructure (i.e., the .ccl files) to complete this Einstein Toolkit module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='toc'></a>\n",
    "\n",
    "# Table of Contents\n",
    "$$\\label{toc}$$\n",
    "\n",
    "This notebook is organized as follows\n",
    "\n",
    "1. [Step 1](#initializenrpy): Call on NRPy+ to convert the SymPy expressions for the Scalar Wave evolution equations' RHSs into a C-code kernel\n",
    "1. [Step 2](#etk): Interfacing with the Einstein Toolkit\n",
    "    1. [Step 2.a](#etkc): Constructing the Einstein Toolkit C-code calling functions that include the C code kernels\n",
    "    1. [Step 2.b](#cclfiles): CCL files - Define how this module interacts and interfaces with the larger Einstein Toolkit infrastructure\n",
    "    1. [Step 2.c](#etk_list): Add the C file to Einstein Toolkit compilation list\n",
    "1. [Step 3](#code_validation): Code Validation, Convergence Tests\n",
    "1. [Step 4](#latex_pdf_output): Output this notebook to $\\LaTeX$-formatted PDF file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='initializenrpy'></a>\n",
    "\n",
    "# Step 1: Call on NRPy+ to convert the SymPy expressions for the Scalar Wave evolution equations' RHSs into a C-code kernel \\[Back to [top](#toc)\\]\n",
    "$$\\label{initializenrpy}$$\n",
    "\n",
    "After importing the core modules, since we are writing an ETK thorn, we'll need to set `\"grid::GridFuncMemAccess\"` to `\"ETK\"`. SymPy expressions for the scalar wave evolution equations' RHSs are written inside [ScalarWave/ScalarWave_RHSs.py](../edit/ScalarWave/ScalarWave_RHSs.py), and we simply import them for use here.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 1a: Import needed NRPy+ core modules:\n",
    "import NRPy_param_funcs as par   # NRPy+: Parameter interface\n",
    "import grid as gri               # NRPy+: Functions having to do with numerical grids\n",
    "import finite_difference as fin  # NRPy+: Finite difference C code generation module\n",
    "from outputC import lhrh         # NRPy+: Core C code output module\n",
    "import loop as lp                # NRPy+: Generate C code loops\n",
    "\n",
    "# Step 1b: This is an Einstein Toolkit (ETK) thorn. Here we\n",
    "#          tell NRPy+ that gridfunction memory access will\n",
    "#          therefore be in the \"ETK\" style.\n",
    "par.set_parval_from_str(\"grid::GridFuncMemAccess\",\"ETK\")\n",
    "\n",
    "# Step 1c: Set the finite differencing order.\n",
    "#         IMPORTANT: If you set FD_CENTDERIVS_ORDER to 8, be sure to use\n",
    "#                    the parameter files and scripts in the directory:\n",
    "#                    WaveToyNRPy/example_parfiles/8thOrder_ConvergenceTest\n",
    "#                    If you set FD_CENTDERIVS_ORDER to 4, be sure to use\n",
    "#                    the parameter files and scripts in the directory:\n",
    "#                    WaveToyNRPy/example_parfiles/4thOrder_ConvergenceTests\n",
    "par.set_parval_from_str(\"finite_difference::FD_CENTDERIVS_ORDER\",4) # SET TO EIGHTH ORDER\n",
    "\n",
    "# Step 1d: Call the ScalarWave_RHSs() function from within the\n",
    "#          ScalarWave/ScalarWave_RHSs.py module.\n",
    "#          This sets swrhs.uu_rhs and swrhs.vv_rhs.\n",
    "import ScalarWave.ScalarWave_RHSs as swrhs\n",
    "swrhs.ScalarWave_RHSs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we need to output these expressions to C code kernel, which will be housed within a file named \"ScalarWave_RHSs.h\". This \"header\" file will be #include'd in the main C file below. Also, so that we can check that the number of ghost zones in the ETK numerical grid is set properly, we will also output the NRPy+ `finite_difference::FD_CENTDERIVS_ORDER parameter` to a `#`define statement within `NRPy_params.h`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 2: Register uu_rhs and vv_rhs gridfunctions so\n",
    "#         they can be written to by NRPy.\n",
    "uu_rhs,vv_rhs = gri.register_gridfunctions(\"AUX\",[\"uu_rhs\",\"vv_rhs\"])\n",
    "\n",
    "# Step 3: Create the C code output kernel.\n",
    "scalar_RHSs_to_print = [\\\n",
    "                        lhrh(lhs=gri.gfaccess(\"out_gfs\",\"uu_rhs\"),rhs=swrhs.uu_rhs),\\\n",
    "                        lhrh(lhs=gri.gfaccess(\"out_gfs\",\"vv_rhs\"),rhs=swrhs.vv_rhs),]\n",
    "scalar_RHSs_CcodeKernel = fin.FD_outputC(\"returnstring\",scalar_RHSs_to_print)\n",
    "\n",
    "scalar_RHSs_looped = lp.loop([\"i2\",\"i1\",\"i0\"],[\"cctk_nghostzones[2]\",\"cctk_nghostzones[1]\",\"cctk_nghostzones[0]\"],\\\n",
    "                             [\"cctk_lsh[2]-cctk_nghostzones[2]\",\"cctk_lsh[1]-cctk_nghostzones[1]\",\\\n",
    "                              \"cctk_lsh[0]-cctk_nghostzones[0]\"],\\\n",
    "                             [\"1\",\"1\",\"1\"],[\"#pragma omp parallel for\",\"\",\"\"],\"\",scalar_RHSs_CcodeKernel)\n",
    "\n",
    "# Step 4: Create directories for the thorn if they don't exist.\n",
    "!mkdir WaveToyNRPy     2>/dev/null # 2>/dev/null: Don't throw an error if the directory already exists.\n",
    "!mkdir WaveToyNRPy/src 2>/dev/null # 2>/dev/null: Don't throw an error if the directory already exists.\n",
    "\n",
    "# Step 5: Write the C code kernel to file.\n",
    "with open(\"WaveToyNRPy/src/ScalarWave_RHSs.h\", \"w\") as file:\n",
    "    file.write(str(scalar_RHSs_looped))\n",
    "\n",
    "with open(\"WaveToyNRPy/src/NRPy_params.h\", \"w\") as file:\n",
    "    file.write(\"#define FD_CENTDERIVS_ORDER \"+str(par.parval_from_str(\"finite_difference::FD_CENTDERIVS_ORDER\"))+\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='etk'></a>\n",
    "\n",
    "# Step 2: Interfacing with the Einstein Toolkit \\[Back to [top](#toc)\\]\n",
    "$$\\label{etk}$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='etkc'></a>\n",
    "\n",
    "## Step 2.a: Constructing the Einstein Toolkit C-code calling functions that include the C code kernels \\[Back to [top](#toc)\\]\n",
    "$$\\label{etkc}$$\n",
    "\n",
    "Now that we have generated the C code kernel `ScalarWave_RHSs.h` and the parameters file `NRPy_params.h`, we will need to write C code to make use of these files. To do this, we can simply follow the example within the [IDScalarWaveNRPy tutorial notebook](Tutorial-ETK_thorn-IDScalarWaveNRPy.ipynb). Functions defined by these files will be called by the Einstein Toolkit scheduler (specified in `schedule.ccl` below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing WaveToyNRPy/src/WaveToyNRPy.c\n"
     ]
    }
   ],
   "source": [
    "%%writefile WaveToyNRPy/src/WaveToyNRPy.c\n",
    "#include <math.h>\n",
    "#include <stdio.h>\n",
    "\n",
    "#include \"cctk.h\"\n",
    "#include \"cctk_Arguments.h\"\n",
    "#include \"cctk_Parameters.h\"\n",
    "#include \"Symmetry.h\"\n",
    "\n",
    "#include \"NRPy_params.h\"\n",
    "\n",
    "void WaveToyNRPy_check_params(CCTK_ARGUMENTS) {\n",
    "    DECLARE_CCTK_ARGUMENTS;\n",
    "\n",
    "    if( (cctk_nghostzones[0] != FD_CENTDERIVS_ORDER/2) ||\n",
    "        (cctk_nghostzones[1] != FD_CENTDERIVS_ORDER/2) ||\n",
    "        (cctk_nghostzones[2] != FD_CENTDERIVS_ORDER/2) ) {\n",
    "            char error_string[200];\n",
    "            sprintf(error_string,\"WaveToyNRPy_check_params: expected ghost_size to be set to %d , but found ghostxyz = %d %d %d\\n\",\n",
    "                    FD_CENTDERIVS_ORDER/2,cctk_nghostzones[0],cctk_nghostzones[1],cctk_nghostzones[2]);\n",
    "            CCTK_WARN (0, error_string);\n",
    "    }\n",
    "}\n",
    "\n",
    "void WaveToyNRPy_set_rhs(CCTK_ARGUMENTS) {\n",
    "  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\n",
    "  const CCTK_REAL invdx0 = 1.0 / (CCTK_DELTA_SPACE(0));\n",
    "  const CCTK_REAL invdx1 = 1.0 / (CCTK_DELTA_SPACE(1));\n",
    "  const CCTK_REAL invdx2 = 1.0 / (CCTK_DELTA_SPACE(2));\n",
    "\n",
    "#include \"ScalarWave_RHSs.h\"\n",
    "}\n",
    "\n",
    "/* Boundary Condition code adapted from WaveToyC thorn in ETK, implementing built-in\n",
    " * ETK BC functionality\n",
    " */\n",
    "void WaveToyNRPy_SelectBCs(CCTK_ARGUMENTS)\n",
    "{\n",
    "  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\n",
    "  const char *bctype;\n",
    "\n",
    "\n",
    "  bctype = NULL;\n",
    "  if (CCTK_EQUALS(bound,\"flat\") || CCTK_EQUALS(bound,\"static\") ||\n",
    "      CCTK_EQUALS(bound,\"radiation\") || CCTK_EQUALS(bound,\"robin\") ||\n",
    "      CCTK_EQUALS(bound,\"none\"))\n",
    "  {\n",
    "    bctype = bound;\n",
    "  }\n",
    "  else if (CCTK_EQUALS(bound,\"zero\"))\n",
    "  {\n",
    "    bctype = \"scalar\";\n",
    "  }\n",
    "\n",
    "  /* Uses all default arguments, so invalid table handle -1 can be passed */\n",
    "  if (bctype && Boundary_SelectVarForBC (cctkGH, CCTK_ALL_FACES, 1, -1,\n",
    "                                         \"WaveToyNRPy::uuGF\", bctype) < 0)\n",
    "  {\n",
    "    CCTK_WARN (0, \"ScalarWave_Boundaries: Error selecting boundary condition\");\n",
    "  }\n",
    "  if (bctype && Boundary_SelectVarForBC (cctkGH, CCTK_ALL_FACES, 1, -1,\n",
    "                                         \"WaveToyNRPy::vvGF\", bctype) < 0)\n",
    "  {\n",
    "    CCTK_WARN (0, \"ScalarWave_Boundaries: Error selecting boundary condition\");\n",
    "  }\n",
    "}\n",
    "\n",
    "void WaveToyNRPy_InitSymBound(CCTK_ARGUMENTS)\n",
    "{\n",
    "  DECLARE_CCTK_ARGUMENTS;\n",
    "\n",
    "  int sym[3];\n",
    "\n",
    "  sym[0] = 1;\n",
    "  sym[1] = 1;\n",
    "  sym[2] = 1;\n",
    "\n",
    "  SetCartSymVN(cctkGH, sym,\"WaveToyNRPy::uuGF\");\n",
    "  SetCartSymVN(cctkGH, sym,\"WaveToyNRPy::vvGF\");\n",
    "\n",
    "  return;\n",
    "}\n",
    "\n",
    "void WaveToyNRPy_RegisterVars(CCTK_ARGUMENTS)\n",
    "{\n",
    "  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\n",
    "  CCTK_INT ierr CCTK_ATTRIBUTE_UNUSED = 0;\n",
    "  /* Register all the evolved grid functions with MoL */\n",
    "  ierr += MoLRegisterEvolved(CCTK_VarIndex(\"WaveToyNRPy::uuGF\"),  CCTK_VarIndex(\"WaveToyNRPy::uu_rhsGF\"));\n",
    "  ierr += MoLRegisterEvolved(CCTK_VarIndex(\"WaveToyNRPy::vvGF\"),  CCTK_VarIndex(\"WaveToyNRPy::vv_rhsGF\"));\n",
    "  /* Register all the evolved Array functions with MoL */\n",
    "  return;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='cclfiles'></a>\n",
    "\n",
    "## Step 2.b: CCL files - Define how this module interacts and interfaces with the larger Einstein Toolkit infrastructure \\[Back to [top](#toc)\\]\n",
    "$$\\label{cclfiles}$$\n",
    "\n",
    "Writing a module (\"thorn\") within the Einstein Toolkit requires that three \"ccl\" files be constructed, all in the root directory of the thorn:\n",
    "\n",
    "1. `interface.ccl`: defines the gridfunction groups needed, and provides keywords denoting what this thorn provides and what it should inherit from other thorns. This file governs the interaction between this thorn and others; more information can be found in the [official Einstein Toolkit documentation](http://einsteintoolkit.org/usersguide/UsersGuidech12.html#x17-178000D2.2). \n",
    "With \"implements\", we give our thorn its unique name. By \"inheriting\" other thorns, we tell the Toolkit that we will rely on variables that exist within those functions. Then, we tell the toolkit that we want the scalars `uuGF` and `vvGF` to be visible to other thorns by using the keyword \"public\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing WaveToyNRPy/interface.ccl\n"
     ]
    }
   ],
   "source": [
    "%%writefile WaveToyNRPy/interface.ccl\n",
    "implements: WaveToyNRPy\n",
    "\n",
    "inherits: Boundary grid\n",
    "\n",
    "USES INCLUDE: loopcontrol.h\n",
    "USES INCLUDE: Symmetry.h\n",
    "USES INCLUDE: Boundary.h\n",
    "\n",
    "CCTK_INT FUNCTION MoLRegisterEvolved(CCTK_INT IN EvolvedIndex, CCTK_INT IN RHSIndex)\n",
    "USES FUNCTION MoLRegisterEvolved\n",
    "\n",
    "CCTK_INT FUNCTION GetBoundarySpecification(CCTK_INT IN size, CCTK_INT OUT ARRAY nboundaryzones, CCTK_INT OUT ARRAY is_internal, CCTK_INT OUT ARRAY is_staggered, CCTK_INT OUT ARRAY shiftout)\n",
    "USES FUNCTION GetBoundarySpecification\n",
    "\n",
    "CCTK_INT FUNCTION SymmetryTableHandleForGrid(CCTK_POINTER_TO_CONST IN cctkGH)\n",
    "USES FUNCTION SymmetryTableHandleForGrid\n",
    "\n",
    "CCTK_INT FUNCTION Boundary_SelectGroupForBC(CCTK_POINTER_TO_CONST IN GH, CCTK_INT IN faces, CCTK_INT IN boundary_width, CCTK_INT IN table_handle, CCTK_STRING IN group_name, CCTK_STRING IN bc_name)\n",
    "USES FUNCTION Boundary_SelectGroupForBC\n",
    "\n",
    "CCTK_INT FUNCTION Boundary_SelectVarForBC(CCTK_POINTER_TO_CONST IN GH, CCTK_INT IN faces, CCTK_INT IN boundary_width, CCTK_INT IN table_handle, CCTK_STRING IN var_name, CCTK_STRING IN bc_name)\n",
    "USES FUNCTION Boundary_SelectVarForBC\n",
    "\n",
    "public:\n",
    "cctk_real scalar_fields_rhs type = GF Timelevels=3 tags='tensortypealias=\"Scalar\"'\n",
    "{\n",
    "  uu_rhsGF,vv_rhsGF\n",
    "} \"The evolved scalar fields\"\n",
    "\n",
    "public:\n",
    "cctk_real scalar_fields type = GF Timelevels=3 tags='tensortypealias=\"Scalar\"'\n",
    "{\n",
    "  uuGF,vvGF\n",
    "} \"The evolved scalar fields\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. `param.ccl`: specifies free parameters within the thorn, enabling them to be set at runtime. It is required to provide allowed ranges and default values for each parameter. More information on this file's syntax can be found in the [official Einstein Toolkit documentation](http://einsteintoolkit.org/usersguide/UsersGuidech12.html#x17-183000D2.3). A number of parameters are defined, and more parameters can be easily added in later versions. We also set the number of timelevels we will store in memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing WaveToyNRPy/param.ccl\n"
     ]
    }
   ],
   "source": [
    "%%writefile WaveToyNRPy/param.ccl\n",
    "shares: MethodOfLines\n",
    "\n",
    "USES CCTK_INT MoL_Num_Evolved_Vars\n",
    "USES CCTK_INT MoL_Num_ArrayEvolved_Vars\n",
    "\n",
    "restricted:\n",
    "CCTK_INT SimpleWave_MaxNumEvolvedVars \"Number of evolved variables used by this thorn\" ACCUMULATOR-BASE=MethodofLines::MoL_Num_Evolved_Vars STEERABLE=RECOVER\n",
    "{\n",
    "  2:2 :: \"Number of evolved variables used by this thorn\"\n",
    "} 2\n",
    "\n",
    "restricted:\n",
    "CCTK_INT SimpleWave_MaxNumArrayEvolvedVars \"Number of Array evolved variables used by this thorn\" ACCUMULATOR-BASE=MethodofLines::MoL_Num_ArrayEvolved_Vars STEERABLE=RECOVER\n",
    "{\n",
    "  0:0 :: \"Number of Array evolved variables used by this thorn\"\n",
    "} 0\n",
    "\n",
    "restricted:\n",
    "KEYWORD bound \"Type of boundary condition to use\"\n",
    "{\n",
    "  \"flat\"      :: \"Flat (von Neumann, n grad phi = 0) boundary condition\"\n",
    "  \"static\"    :: \"Static (Dirichlet, dphi/dt=0) boundary condition\"\n",
    "  \"radiation\" :: \"Radiation boundary condition\"\n",
    "  \"robin\"     :: \"Robin (phi(r) = C/r) boundary condition\"\n",
    "  \"zero\"      :: \"Zero (Dirichlet, phi=0) boundary condition\"\n",
    "  \"none\"      :: \"Apply no boundary condition\"\n",
    "} \"static\"\n",
    "\n",
    "restricted:\n",
    "CCTK_INT timelevels \"Number of active timelevels\" STEERABLE=RECOVER\n",
    "{\n",
    "  0:3 :: \"\"\n",
    "} 3\n",
    "\n",
    "restricted:\n",
    "CCTK_REAL wavespeed \"The speed at which the wave propagates\"\n",
    "{\n",
    " *:* :: \"Wavespeed as a multiple of c\"\n",
    "} 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. `schedule.ccl`: allocates storage for gridfunctions, defines how the thorn's functions should be scheduled in a broader simulation, and specifies the regions of memory written to or read from gridfunctions. `schedule.ccl`'s official documentation may be found [here](http://einsteintoolkit.org/usersguide/UsersGuidech12.html#x17-186000D2.4). \n",
    "\n",
    "We first assign storage for both scalar gridfunctions, and then specify the standardized ETK \"scheduling bins\" in which we want each of our thorn's functions to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing WaveToyNRPy/schedule.ccl\n"
     ]
    }
   ],
   "source": [
    "%%writefile WaveToyNRPy/schedule.ccl\n",
    "STORAGE: scalar_fields_rhs[timelevels]\n",
    "STORAGE: scalar_fields[timelevels]\n",
    "\n",
    "schedule WaveToyNRPy_InitSymBound at BASEGRID\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: global\n",
    "} \"Schedule symmetries\"\n",
    "\n",
    "schedule WaveToyNRPy_check_params at CCTK_PARAMCHECK\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: global\n",
    "} \"Check sanity of parameters\"\n",
    "\n",
    "schedule WaveToyNRPy_set_rhs as WaveToy_Evolution IN MoL_CalcRHS\n",
    "{\n",
    "  LANG: C\n",
    "  READS: uuGF(Everywhere)\n",
    "  READS: vvGF(Everywhere)\n",
    "  WRITES: uu_rhsGF(Interior)\n",
    "  WRITES: VV_rhsGF(Interior)\n",
    "    # FIXME: Add syncs\n",
    "} \"Evolution of 3D wave equation\"\n",
    "\n",
    "schedule WaveToyNRPy_SelectBCs in MoL_PostStep\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: level\n",
    "  SYNC: scalar_fields\n",
    "} \"Boundaries of 3D wave equation\"\n",
    "\n",
    "schedule GROUP ApplyBCs as WaveToyNRPy_ApplyBCs in MoL_PostStep after WaveToyNRPy_SelectBCs\n",
    "{\n",
    "} \"Apply boundary conditions\"\n",
    "\n",
    "\n",
    "schedule GROUP ApplyBCs as WaveToyNRPy_ApplyBCs at POSTRESTRICT\n",
    "{\n",
    "} \"Apply boundary conditions\"\n",
    "\n",
    "schedule WaveToyNRPy_RegisterVars in MoL_Register\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: meta\n",
    "} \"Register Variables for MoL\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='etk_list'></a>\n",
    "\n",
    "## Step 2.c: Add the C file to Einstein Toolkit compilation list \\[Back to [top](#toc)\\]\n",
    "$$\\label{etk_list}$$\n",
    "\n",
    "We will also need `make.code.defn`, which indicates the list of files that need to be compiled. This thorn only has the one C file to compile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing WaveToyNRPy/src/make.code.defn\n"
     ]
    }
   ],
   "source": [
    "%%writefile WaveToyNRPy/src/make.code.defn\n",
    "SRCS = WaveToyNRPy.c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='code_validation'></a>\n",
    "\n",
    "# Step 3: Code Validation, Convergence Tests \\[Back to [top](#toc)\\]\n",
    "$$\\label{code_validation}$$\n",
    "\n",
    "We have performed a number of convergence tests with $\\text{WaveToyNRPy}$ and $\\text{IDScalarWaveNRPy}$ within the ETK, which are presented below. \n",
    "\n",
    "**One and three-dimensional scalar wave equation code tests, adopting fourth-order finite differencing, coupled to RK4 method-of-lines for time integration**\n",
    "\n",
    "Inside the directory *`WaveToyNRPy/example_parfiles/4thOrder_ConvergenceTests/`* are the files used for this convergence test:\n",
    "1. **1D-planewave-\\*.par** : ETK parameter files needed for performing the 1D tests. These parameter files set up a sinusoidal wave propagating along the x-axis of a numerical grid that is of minimal extent in the y and z directions, but extends from -12 to +12 along the x-axis (in units of $\\omega=k=c=1$). The parameter files are identical, except one has grid resolution that is twice as high (so the errors should drop in the higher resolution case by a factor of $2^4$, since we adopt fourth-order-convergent timestepping and spatial finite differencing.)\n",
    "1. **planewave_along_3D_diagonal\\*.par** : ETK parameter files needed for performing the 3D tests. These parameter files set up a sinusoidal plane wave propagating along the x=y=z diagonal of a 3D numerical grid that extends from -12 to +12 along the x-, y-, and z-axis (in units of $\\omega=k=c=1$). The parameter files are identical, except one has grid resolution that is twice as high (so the errors should drop in the higher resolution case by a factor of $2^4$, since we adopt fourth-order-convergent timestepping and spatial finite differencing.)\n",
    "1. **runscript.sh** : Runs the cactus executable (assumed to be named *cactus_etilgrmhd-FD4*) for all of the above parameter files.\n",
    "    1. **convert_IOASCII_1D_to_gnuplot.sh** : Used by **runscript.sh** to convert the 1D output from the execution into a format that [gnuplot](http://gnuplot.info/) can recognize.\n",
    "1. **gnuplot_script** : Script for creating code validation convergence plots with [gnuplot](http://gnuplot.info/).\n",
    "\n",
    "**Fourth-order code validation test results:**\n",
    "\n",
    "We start with the 1D tests. The plot below shows the discrepancy between numerical and exact solutions to the scalar wave equation at two different resolutions: purple is low resolution ($\\Delta x_{\\rm low}=0.4$) and green is high resolution ($\\Delta x_{\\rm high}=0.2$). Since this test adopts fourth-order finite differencing for spatial derivatives and fourth-order Runge-Kutta (RK4) for timestepping, we would expect this error to drop by a factor of approximately $(\\Delta x_{\\rm low}/\\Delta x_{\\rm high})^4 = (0.4/0.2)^4 = 2^4=16$ when going from low to high resolution, and after rescaling the error in the high-resolution case by 16, we see that indeed it overlaps the low-resolution result quite nicely, confirming fourth-order convergence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 8,
     "metadata": {
      "image/png": {
       "height": 600,
       "width": 600
      }
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"./WaveToyNRPy/example_parfiles/4thOrder_ConvergenceTests/out-RK4-FD4-1D.png\", width=600, height=600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we perform the same test, but with a plane wave propagating along the x=y=z diagonal. This test verifies that errors in propagation along the y and z directions converge to zero as expected as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 9,
     "metadata": {
      "image/png": {
       "height": 600,
       "width": 600
      }
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(\"./WaveToyNRPy/example_parfiles/4thOrder_ConvergenceTests/out-RK4-FD4-3D.png\", width=600, height=600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Three-dimensional scalar wave equation code tests, adopting *eighth*-order finite differencing, coupled to *RK8* method-of-lines for time integration\n",
    "\n",
    "Inside the directory *`WaveToyNRPy/example_parfiles/8thOrder_ConvergenceTests/`* are the files used for this convergence test:\n",
    "1. **planewave_along_3D_diagonal\\*.par** : ETK parameter files needed for performing the 3D tests. These parameter files set up a sinusoidal plane wave propagating along the x=y=z diagonal of a 3D numerical grid that extends from -12 to +12 along the x-, y-, and z-axis (in units of $\\omega=k=c=1$). The parameter files are identical, except one has grid resolution that is twice as high (so the errors should drop in the higher resolution case by a factor of $2^4$, since we adopt fourth-order-convergent timestepping and spatial finite differencing.)\n",
    "1. **runscript.sh** : Runs the cactus executable (assumed to be named *cactus_etilgrmhd-FD8*) for all of the above parameter files.\n",
    "    1. **convert_IOASCII_1D_to_gnuplot.sh** : Used by **runscript.sh** to convert the 1D output from the execution into a format that [gnuplot](http://gnuplot.info/) can recognize.\n",
    "1. **gnuplot_script** : Script for creating code validation convergence plots with [gnuplot](http://gnuplot.info/).\n",
    "\n",
    "**Eighth-order code validation test results:**\n",
    "\n",
    "The plot below shows the discrepancy between numerical and exact solutions to the scalar wave equation at two different resolutions: purple is low resolution ($\\Delta x_{\\rm low}=0.4$) and green is high resolution ($\\Delta x_{\\rm high}=0.2$). Since this test adopts **eighth**-order finite differencing for spatial derivatives and **eighth**-order Runge-Kutta (RK8) for timestepping, we would expect this error to drop by a factor of approximately $(\\Delta x_{\\rm low}/\\Delta x_{\\rm high})^8 = (0.4/0.2)^8 = 2^8=256$ when going from low to high resolution, and after rescaling the error in the high-resolution case by 16, we see that indeed it overlaps the low-resolution result quite nicely, confirming fourth-order convergence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 10,
     "metadata": {
      "image/png": {
       "height": 600,
       "width": 600
      }
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(\"WaveToyNRPy/example_parfiles/8thOrder_ConvergenceTest/FD8-RK8__test_output_plot.png\", width=600, height=600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='latex_pdf_output'></a>\n",
    "\n",
    "# Step 4: Output this notebook to $\\LaTeX$-formatted PDF file \\[Back to [top](#toc)\\]\n",
    "$$\\label{latex_pdf_output}$$\n",
    "\n",
    "The following code cell converts this Jupyter notebook into a proper, clickable $\\LaTeX$-formatted PDF file. After the cell is successfully run, the generated PDF may be found in the root NRPy+ tutorial directory, with filename\n",
    "[Tutorial-ETK_thorn-WaveToyNRPy.pdf](Tutorial-ETK_thorn-WaveToyNRPy.pdf) (Note that clicking on this link may not work; you may need to open the PDF file through another means.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created Tutorial-ETK_thorn-WaveToyNRPy.tex, and compiled LaTeX file to PDF\n",
      "    file Tutorial-ETK_thorn-WaveToyNRPy.pdf\n"
     ]
    }
   ],
   "source": [
    "import cmdline_helper as cmd    # NRPy+: Multi-platform Python command-line interface\n",
    "cmd.output_Jupyter_notebook_to_LaTeXed_PDF(\"Tutorial-ETK_thorn-WaveToyNRPy\")"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}