Tutorial-BaikalETK_new_way.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",
    "# `BaikalETK`: NRPy+-Based BSSN Solvers for the Einstein Toolkit\n",
    "\n",
    "## Author: Zach Etienne\n",
    "\n",
    "#### Special thanks to Roland Haas for help in answering many implementation questions\n",
    "\n",
    "## This notebook generates `Baikal` and `BaikalVacuum`, [Einstein Toolkit](https://einsteintoolkit.org) thorns for solving Einstein's equations in the BSSN formalism, in Cartesian coordinates. These thorns are highly optimized for modern CPU architectures, featuring SIMD intrinsics and OpenMP support.\n",
    "\n",
    "**Notebook Status:** <font color='orange'><b> Validated against the Einstein Toolkit `McLachlan` BSSN thorn, both in the context of black hole binary simulations (excellent gravitational waveform agreement) as well as binary neutron star simulations (when parameter `enable_stress_energy_source_terms` below is set to `True`). Once plots demonstrating this agreement are added to this tutorial notebook, the validation status will be set to</b></font> <font color='green'><b>Validated</b></font>.\n",
    "\n",
    "**Validation Notes:** This tutorial notebook has been validated against a trusted Einstein Toolkit thorn, but plots demonstrating its validation have yet to be included in this notebook.\n",
    "\n",
    "## Introduction\n",
    "\n",
    "```\n",
    "How often did my soul cry out:\n",
    "Come back to Baikal once again?\n",
    "I still do not know this lake:\n",
    "To see does not mean to know.\n",
    "```\n",
    "[Igor Severyanin](https://en.wikipedia.org/wiki/Igor_Severyanin), [[1]](https://1baikal.ru/en/istoriya/let’s-turn-to-baikal-a-poetic-view).\n",
    "\n",
    "[Lake Baikal](https://en.wikipedia.org/wiki/Lake_Baikal) is home to the [nerpa seal](https://en.wikipedia.org/wiki/Baikal_seal), NRPy+'s mascot.\n",
    "\n",
    "This notebook generates two thorns: `Baikal` and `BaikalVacuum`. `Baikal` contains stress-energy source terms (i.e., the $8\\pi T^{\\mu\\nu}$ part of Einstein's equations) for general relativistic hydrodynamics (GRHD) and magnetohydrodynamics (GRMHD), and the `BaikalVacuum` contains no such source terms, so can be used for e.g., black hole and binary black hole calculations in which no self-gravitating matter is considered.\n",
    "\n",
    "`Baikal` and `BaikalVacuum` are meant to reproduce the functionality of the `McLachlan` thorn, generated by the [Mathematica](https://www.wolfram.com/mathematica/)-based [Kranc](http://kranccode.org/) code, but using the fully open-source NRPy+/SymPy infrastructure.\n",
    "\n",
    "Unlike `McLachlan`, `Baikal` and `BaikalVacuum` enable the user at runtime to select only the most popular options, like finite-difference order and Kreiss-Oliger dissipation strength. Further, neither thorn yet supports symmetry options or Jacobians needed for `Llama` grids. Support for these options might be provided in a future update. As for BSSN gauge choice, `Baikal` and `BaikalVacuum` by default support only the BSSN moving-puncture gauge conditions, though this can be changed by selecting one of the [other gauge choices implemented within the NRPy+ infrastructure](Tutorial-BSSN_time_evolution-BSSN_gauge_RHSs.ipynb).  \n",
    "\n",
    "**Regarding the structure of this notebook:**\n",
    "\n",
    "As generating the optimized C code kernels needed for these thorns can *individually* take roughly 10 minutes per finite-difference order, there is a strong motivation to parallelize the code generation process. \n",
    "\n",
    "To this end, this Jupyter notebook makes use of Python's [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html) module, which spawns an independent Python interpreter to construct individual C-code kernels. On a modern, multi-core CPU, this greatly cuts down the time needed to generate the thorns (sometimes by 10x or more), all while ensuring a convenient user interface for adjusting the thorns to suit one's needs.\n",
    "\n",
    "One significant complication arises with the use of `multiprocessing`: the NRPy+ environment. Each Python interpreter inherits the NRPy+ environment of the parent interpreter from which it spawns. Within each interpreter NRPy+ registers an additional individual C function within NRPy+'s [`outputC`](outputC.py) module. But how to combine all of these individual NRPy+ environments back into the parent after `multiprocessing` is run? The answer lies in NRPy+'s [`pickling`](pickling.py) module, which uses Python's built-in [`pickle`](https://docs.python.org/3/library/pickle.html) module to store (\"pickle\") an entire NRPy+ environment and add it to the parent NRPy+ environment (\"unpickle\").\n",
    "\n",
    "### Associated NRPy+ Source Code & Tutorial Modules for this module: \n",
    "* [BSSN/ADM_Numerical_Spherical_or_Cartesian_to_BSSNCurvilinear.py](BSSN/ADM_Numerical_Spherical_or_Cartesian_to_BSSNCurvilinear.py); [\\[**tutorial**\\]](Tutorial-ADM_Initial_Data-Converting_Exact_ADM_Spherical_or_Cartesian_to_BSSNCurvilinear.ipynb): Spherical/Cartesian ADM$\\to$Curvilinear BSSN converter function, for which ADM quantities are assumed given at each gridpoint (i.e., exact, closed-form expressions are not given). This is used to generate BaikalETK's ADM$\\to$BSSN function, as in the ETK spacetime evolution modules are to assume that initial data are given as ADM quantities in the Cartesian basis at each gridpoint.\n",
    "* [BSSN/ADM_in_terms_of_BSSN.py](BSSN/ADM_in_terms_of_BSSN.py); [\\[**tutorial**\\]](Tutorial-ADM_in_terms_of_BSSN.ipynb): Constructs ADM quantities in terms of BSSN quantities (in arbitrary curvilinear coordinates, though we use Cartesian here). This is used to generate BaikalETK's BSSN$\\to$ADM function, which make ADM variables available to diagnostic thorns within the ETK.\n",
    "* [BSSN/BSSN_Ccodegen_library.py](BSSN/BSSN_Ccodegen_library.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-C_codegen_library.ipynb): BSSN C code generation library, which contains a library of Python functions for generating & registering BSSN C functions within NRPy+'s [`outputC`](outputC.py) module, including\n",
    "    * BSSN constraints (symbolic expression [Python module](BSSN/BSSN_constraints.py) and [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_RHSs.ipynb))\n",
    "    * BSSN time evolution equation right-hand sides (RHSs) for spacetime quantities ([Python module](BSSN/BSSN_RHSs.py) and [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_RHSs.ipynb))\n",
    "    * BSSN time evolution equation right-hand sides (RHSs) for gauge quantities ([Python module](BSSN/BSSN_gauge_RHSs.py) and [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_gauge_RHSs.ipynb)"
   ]
  },
  {
   "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): Initialize needed Python/NRPy+ modules\n",
    "1. [Step 2](#bssn): Description of C codes generated for BSSN spacetime solve\n",
    "    1. [Step 2.a](#bssnrhs): BSSN right-hand-side (RHS) expressions\n",
    "    1. [Step 2.b](#hammomconstraints): Hamiltonian & momentum constraints\n",
    "    1. [Step 2.c](#gamconstraint): Enforce conformal 3-metric $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ constraint (in Cartesian coordinates, $\\det{\\hat{\\gamma}_{ij}}=1$)\n",
    "1. [Step 3](#kernel_codegen): Generation of C code functions for `Baikal` and `BaikalVacuum`\n",
    "    1. [Step 3.a](#feature_choice): Set compile-time and runtime parameters for `Baikal` and `BaikalVacuum`\n",
    "    1. [Step 3.b](#parallel_codegen): Generate all C-code kernels for `Baikal` and `BaikalVacuum`, in parallel if possible\n",
    "1. [Step 4](#cclfiles): CCL files - Define how this module interacts and interfaces with the wider Einstein Toolkit infrastructure\n",
    "    1. [Step 4.a](#paramccl): `param.ccl`: specify free parameters within `Baikal`/`BaikalVacuum`\n",
    "    1. [Step 4.b](#interfaceccl): `interface.ccl`: define needed gridfunctions; provide keywords denoting what this thorn provides and what it should inherit from other thorns\n",
    "    1. [Step 4.c](#scheduleccl): `schedule.ccl`:schedule all functions used within `Baikal`/`BaikalVacuum`, specify data dependencies within said functions, and allocate memory for gridfunctions\n",
    "1. [Step 5](#cdrivers): Register library of C functions needed for interfacing with the `Einstein Toolkit`\n",
    "    1. [Step 5.a](#etkfunctions): Needed ETK functions: Banner, Symmetry registration, Parameter sanity check,  Method of Lines (`MoL`) registration, Boundary condition registration\n",
    "    1. [Step 5.b](#bssnadmconversions): BSSN $\\leftrightarrow$ ADM conversions\n",
    "        1. [Step 5.b.i](#admtobssn): ADM $\\to$ BSSN\n",
    "        1. [Step 5.b.ii](#bssntoadm): BSSN $\\to$ ADM\n",
    "    1. [Step 5.c](#t4uu): `T4DD_to_T4UU()`: Compute $T^{\\mu\\nu}$ from `TmunuBase`'s $T_{\\mu\\nu}$, using BSSN quantities as inputs for the 4D raising operation\n",
    "1. [Step 6](#outcdrivers): Output all C driver functions needed for `Baikal`/`BaikalVacuum`\n",
    "    1. [Step 6.a](#makecodedefn): `make.code.defn`: List of all C driver functions needed to compile `BaikalETK`\n",
    "1. [Step 7](#code_validation): Code Validation\n",
    "    1. [Step 7.a](#self_validation): Validation against [BaikalETK/](BaikalETK/) Python modules\n",
    "1. [Step 8](#latex_pdf_output): Output this notebook to $\\LaTeX$-formatted PDF file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='initializenrpy'></a>\n",
    "\n",
    "# Step 1: Initialize needed Python/NRPy+ modules \\[Back to [top](#toc)\\]\n",
    "\n",
    "$$\\label{initializenrpy}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:16:59.827996Z",
     "iopub.status.busy": "2021-12-20T04:16:59.826600Z",
     "iopub.status.idle": "2021-12-20T04:17:00.101094Z",
     "shell.execute_reply": "2021-12-20T04:17:00.100141Z"
    }
   },
   "outputs": [],
   "source": [
    "# Step 1: Import needed core NRPy+ modules\n",
    "from outputC import outC_function_master_list, indent_Ccode, lhrh, add_to_Cfunction_dict  # NRPy+: Core C code output module\n",
    "from pickling import unpickle_NRPy_env  # NRPy+: pickle/unpickle NRPy+ environment; needed for parallel codegen\n",
    "import finite_difference as fin  # NRPy+: Finite difference C code generation module\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 loop as lp                # NRPy+: Generate C code loops\n",
    "import indexedexp as ixp         # NRPy+: Symbolic indexed expression (e.g., tensors, vectors, etc.) support\n",
    "import reference_metric as rfm   # NRPy+: Reference metric support\n",
    "import cmdline_helper as cmd     # NRPy+: Multi-platform Python command-line interface\n",
    "import os, sys, shutil           # Standard Python modules for multiplatform OS-level functions\n",
    "import time                      # Standard Python module; useful for benchmarking\n",
    "import BSSN.BSSN_gauge_RHSs as gaugerhss\n",
    "\n",
    "# Compile-time (i.e., NRPy+-time) parameters for both Baikal & BaikalVacuum:\n",
    "LapseCondition = \"OnePlusLog\"\n",
    "ShiftCondition = \"GammaDriving2ndOrder_NoCovariant\"\n",
    "enable_golden_kernels = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:17:00.110300Z",
     "iopub.status.busy": "2021-12-20T04:17:00.109398Z",
     "iopub.status.idle": "2021-12-20T04:17:00.148988Z",
     "shell.execute_reply": "2021-12-20T04:17:00.148074Z"
    }
   },
   "outputs": [],
   "source": [
    "import reference_metric as rfm\n",
    "par.set_parval_from_str(\"reference_metric::CoordSystem\", \"Cartesian\")\n",
    "rfm.reference_metric() # Sets up coordinate system within NRPy+; needed for generating BSSN RHSs, etc.\n",
    "par.set_parval_from_str(\"grid::GridFuncMemAccess\", \"ETK\")\n",
    "par.set_parval_from_str(\"BSSN.BSSN_gauge_RHSs::ShiftEvolutionOption\", ShiftCondition)\n",
    "par.set_parval_from_str(\"BSSN.BSSN_gauge_RHSs::LapseEvolutionOption\", LapseCondition)\n",
    "\n",
    "# Output finite difference stencils as functions instead of inlined expressions.\n",
    "#   Dramatically speeds up compile times (esp with higher-order finite differences\n",
    "#   and GCC 9.3+)\n",
    "par.set_parval_from_str(\"finite_difference::enable_FD_functions\", True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:17:00.154834Z",
     "iopub.status.busy": "2021-12-20T04:17:00.154422Z",
     "iopub.status.idle": "2021-12-20T04:17:00.159335Z",
     "shell.execute_reply": "2021-12-20T04:17:00.158869Z"
    }
   },
   "outputs": [],
   "source": [
    "for thornname in [\"Baikal\", \"BaikalVacuum\"]:\n",
    "    # First remove C code output directory if it exists\n",
    "    # Courtesy https://stackoverflow.com/questions/303200/how-do-i-remove-delete-a-folder-that-is-not-empty\n",
    "    shutil.rmtree(thornname, ignore_errors=True)\n",
    "\n",
    "    cmd.mkdir(os.path.join(thornname))\n",
    "    cmd.mkdir(os.path.join(thornname, \"src\"))\n",
    "\n",
    "    cmd.mkdir(os.path.join(thornname, \"src\", \"SIMD\"))\n",
    "    import fileinput\n",
    "    f = fileinput.input(os.path.join(\"SIMD\", \"SIMD_intrinsics.h\"))\n",
    "    with open(os.path.join(thornname, \"src\", \"SIMD\", \"SIMD_intrinsics.h\"),\"w\") as outfile:\n",
    "        for line in f:\n",
    "            outfile.write(line.replace(\"#define REAL_SIMD_ARRAY REAL\", \"#define REAL_SIMD_ARRAY CCTK_REAL\"))\n",
    "\n",
    "    # Create directory for rfm_files output\n",
    "    cmd.mkdir(os.path.join(thornname, \"src\", \"rfm_files\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='bssn'></a>\n",
    "\n",
    "# Step 2: Description of C codes generated for BSSN spacetime solve \\[Back to [top](#toc)\\]\n",
    "$$\\label{bssn}$$\n",
    "\n",
    "<a id='bssnrhs'></a>\n",
    "\n",
    "## Step 2.a: BSSN RHS expressions \\[Back to [top](#toc)\\]\n",
    "$$\\label{bssnrhs}$$\n",
    "\n",
    "`BaikalETK` implements a fully covariant version of the BSSN 3+1 decomposition of Einstein's equations of general relativity, which is fully documented within NRPy+ ([start here](Tutorial-BSSN_formulation.ipynb)). However, especially if you are a newcomer to the field of numerical relativity, you may also find the following lectures and papers useful for understanding the adopted formalism:\n",
    "\n",
    "* Mathematical foundations of BSSN and 3+1 initial value problem decompositions of Einstein's equations:\n",
    "    * [Thomas Baumgarte's lectures on mathematical formulation of numerical relativity](https://www.youtube.com/watch?v=t3uo2R-yu4o&list=PLRVOWML3TL_djTd_nsTlq5aJjJET42Qke)\n",
    "    * [Yuichiro Sekiguchi's introduction to BSSN](http://www2.yukawa.kyoto-u.ac.jp/~yuichiro.sekiguchi/3+1.pdf) \n",
    "* Extensions to the standard BSSN approach used in NRPy+\n",
    "    * [Brown's covariant \"Lagrangian\" formalism of BSSN](https://arxiv.org/abs/0902.3652)\n",
    "    * [BSSN in spherical coordinates, using the reference-metric approach of Baumgarte, Montero, Cordero-Carrión, and Müller (2012)](https://arxiv.org/abs/1211.6632)\n",
    "    * [BSSN in generic curvilinear coordinates, using the extended reference-metric approach of Ruchlin, Etienne, and Baumgarte (2018)](https://arxiv.org/abs/1712.07658)\n",
    "\n",
    "Here, we simply call the [BSSN.BSSN_RHSs](BSSN/BSSN_RHSs.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_RHSs.ipynb) and [BSSN.BSSN_gauge_RHSs](BSSN/BSSN_gauge_RHSs.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_gauge_RHSs.ipynb) NRPy+ Python modules to generate the symbolic expressions, add Kreiss-Oliger dissipation, and then output the finite-difference C code form of the equations using NRPy+'s [finite_difference](finite_difference.py) ([**tutorial**](Tutorial-Finite_Difference_Derivatives.ipynb)) C code generation module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='hammomconstraints'></a>\n",
    "\n",
    "## Step 2.b: Hamiltonian & momentum constraints \\[Back to [top](#toc)\\]\n",
    "$$\\label{hammomconstraints}$$\n",
    "\n",
    "Next output the C code for evaluating the Hamiltonian & momentum constraints [(**Tutorial**)](Tutorial-BSSN_constraints.ipynb). In the absence of numerical error, this constraint should evaluate to zero. However it does not due to numerical (typically truncation and roundoff) error. Therefore it is useful to measure the Hamiltonian & momentum constraint violation to gauge the accuracy of our simulation, and, ultimately determine whether errors are dominated by numerical finite differencing (truncation) error as expected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='gamconstraint'></a>\n",
    "\n",
    "## Step 2.c: Enforce conformal 3-metric $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ constraint (in Cartesian coordinates, $\\det{\\hat{\\gamma}_{ij}}=1$) \\[Back to [top](#toc)\\]\n",
    "$$\\label{gamconstraint}$$\n",
    "\n",
    "Then enforce conformal 3-metric $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ constraint (Eq. 53 of [Ruchlin, Etienne, and Baumgarte (2018)](https://arxiv.org/abs/1712.07658)), as [documented in the corresponding NRPy+ tutorial notebook](Tutorial-BSSN_enforcing_determinant_gammabar_equals_gammahat_constraint.ipynb)\n",
    "\n",
    "Applying curvilinear boundary conditions should affect the initial data at the outer boundary, and will in general cause the $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ constraint to be violated there. Thus after we apply these boundary conditions, we must always call the routine for enforcing the $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ constraint:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='kernel_codegen'></a>\n",
    "\n",
    "# Step 3: Generation of C code functions for `Baikal` and `BaikalVacuum` \\[Back to [top](#toc)\\]\n",
    "$$\\label{kernel_codegen}$$\n",
    "\n",
    "Here we generate the C code kernels (i.e., the C-code representation of the equations needed) for `Baikal` and `BaikalVacuum`.\n",
    "\n",
    "<a id='feature_choice'></a>\n",
    "\n",
    "## Step 3.a: Set compile-time and runtime parameters for `Baikal` and `BaikalVacuum` \\[Back to [top](#toc)\\]\n",
    "$$\\label{feature_choice}$$\n",
    "\n",
    "NRPy+ is a code generation package that is designed to offer maximum flexibility *at the time of C code generation*. As a result, although NRPy+ can in principle output an infinite variety of C code kernels for solving Einstein's equations, generally free parameters in each kernel steerable at *runtime* are restricted to simple scalars. This leads to more optimized kernels (i.e., significantly improved performance as compared to `McLachlan`), but at the expense of flexibility in choosing e.g., different gauges at runtime (currently only the most commonly used gauge is supported), as well as the need to generate multiple kernels (one per finite-differencing order). Reducing the number of kernels and adding more flexibility at runtime will be a focus of future work.\n",
    "\n",
    "For now, `Baikal` and `BaikalVacuum` support the following runtime options:\n",
    "\n",
    "* `Baikal`: Enables $T^{\\mu\\nu}$ source terms; useful for general relativistic hydrodynamics (GRHD) and general relativistic magnetohydrodynamics (GRMHD) simulations.\n",
    "    * Finite differencing of order 2 and 4, via runtime parameter `FD_order`\n",
    "        * BSSN RHSs, Ricci tensor, Hamiltonian constraint, and $\\hat{\\gamma}=\\bar{\\gamma}$ constraint\n",
    "    * Kreiss-Oliger dissipation strength via runtime parameter `diss_strength`, which is the exact analogue of the `eps_diss` parameter of the `Dissipation` thorn\n",
    "* `BaikalVacuum`: Disables $T^{\\mu\\nu}$ source terms; useful for generating dynamical black hole and binary black hole spacetimes, in which matter is not present.\n",
    "    * Finite differencing of orders 4, 6, and 8 via runtime parameter `FD_order`\n",
    "        * BSSN RHSs, Ricci tensor, Hamiltonian constraint, and $\\hat{\\gamma}=\\bar{\\gamma}$ constraint\n",
    "    * Kreiss-Oliger dissipation strength via runtime parameter `diss_strength`, which is the exact analogue of the `eps_diss` parameter of the `Dissipation` thorn\n",
    "\n",
    "Both thorns adopt the standard moving-puncture gauge conditions, which include the 1+log slicing condition for the lapse and the non-covariant $\\Gamma$-driving shift condition, as documented [in this NRPy+ Tutorial notebook](Tutorial-BSSN_time_evolution-BSSN_gauge_RHSs.ipynb), and implemented in [the corresponding NRPy+ Python module](BSSN/BSSN_gauge_RHSs.py). In case you'd like to make another gauge choice, you need only choose the desired gauge from [the NRPy+ Python module](BSSN/BSSN_gauge_RHSs.py) and add it as parameters `ShiftCondition` and `LapseCondition` to the main BaikalETK code generation function `BaikalETK_C_kernels_codegen_onepart()`. You will find that adding user-defined gauge choices is a straightforward process, as the module is easily extended.\n",
    "\n",
    "Next we set up the default parameters for `Baikal` and `BaikalVacuum` thorns and call them from within Python's `multiprocessing.Pool()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:17:00.171132Z",
     "iopub.status.busy": "2021-12-20T04:17:00.170600Z",
     "iopub.status.idle": "2021-12-20T04:19:21.804523Z",
     "shell.execute_reply": "2021-12-20T04:19:21.804888Z"
    }
   },
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "funcarg = namedtuple('funcarg', 'name thornname fdorder')\n",
    "\n",
    "import BSSN.BSSN_Ccodegen_library as BCL\n",
    "\n",
    "BSSN_funcs = []\n",
    "\n",
    "Baikal_FDorders_list = [2, 4]\n",
    "BaikalVacuum_FDorders_list = [4, 6, 8]\n",
    "\n",
    "for thornname in [\"Baikal\", \"BaikalVacuum\"]:\n",
    "#     BSSN_funcs  = [funcarg(name=BCL.add_to_Cfunction_dict_BSSN_to_ADM, thornname=thornname, fdorder=None)]\n",
    "    BSSN_funcs += [funcarg(name=BCL.add_enforce_detgammahat_constraint_to_Cfunction_dict, thornname=thornname,\n",
    "                           fdorder=None)]\n",
    "    fdorder_list = Baikal_FDorders_list\n",
    "    if thornname == \"BaikalVacuum\":\n",
    "        fdorder_list = BaikalVacuum_FDorders_list\n",
    "    for fdorder in fdorder_list:\n",
    "        BSSN_funcs += [funcarg(name=BCL.add_rhs_eval_to_Cfunction_dict, thornname=thornname, fdorder=fdorder)]\n",
    "        BSSN_funcs += [funcarg(name=BCL.add_Ricci_eval_to_Cfunction_dict, thornname=thornname, fdorder=fdorder)]\n",
    "        BSSN_funcs += [funcarg(name=BCL.add_BSSN_constraints_to_Cfunction_dict,\n",
    "                               thornname=thornname, fdorder=fdorder)]\n",
    "#         BSSN_funcs  = [funcarg(name=BCL.add_to_Cfunction_dict_ADM_to_BSSN, thornname=thornname, fdorder=fdorder)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='parallel_codegen'></a>\n",
    "\n",
    "## Step 3.b: Generate all C-code kernels for `Baikal` and `BaikalVacuum`, in parallel if possible \\[Back to [top](#toc)\\]\n",
    "$$\\label{parallel_codegen}$$\n",
    "\n",
    "As described above, a significant complication arises with the use of `multiprocessing`: the NRPy+ environment. Each Python interpreter inherits the NRPy+ environment of the parent interpreter from which it spawns. Within each interpreter NRPy+ registers an additional individual C function within NRPy+'s [`outputC`](outputC.py) module. But how to combine all of these individual NRPy+ environments back into the parent after `multiprocessing` is run? The answer lies in NRPy+'s [`pickling`](pickling.py) module, which uses Python's built-in [`pickle`](https://docs.python.org/3/library/pickle.html) module to store (\"pickle\") an entire NRPy+ environment and add it to the parent NRPy+ environment (\"unpickle\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:17:00.171132Z",
     "iopub.status.busy": "2021-12-20T04:17:00.170600Z",
     "iopub.status.idle": "2021-12-20T04:19:21.804523Z",
     "shell.execute_reply": "2021-12-20T04:19:21.804888Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating symbolic expressions for BSSN constraints (Cartesian coords)...Generating symbolic expressions for BSSN constraints (Cartesian coords)...Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...\n",
      "Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...\n",
      "Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...\n",
      "\n",
      "Generating symbolic expressions for BSSN constraints (Cartesian coords)...\n",
      "Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...Generating symbolic expressions for BSSN constraints (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...\n",
      "Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...Generating symbolic expressions for BSSN_RHSs (Cartesian coords)...\n",
      "\n",
      "Generating symbolic expressions for 3-Ricci tensor (Cartesian coords)...\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "Generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Cartesian coords)...Generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Cartesian coords)...\n",
      "\n",
      "Finished generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Cartesian coords) in 0.1 seconds.\n",
      "Generating symbolic expressions for BSSN constraints (Cartesian coords)...\n",
      "Finished generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Cartesian coords) in 0.1 seconds.\n",
      "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 0.5 seconds. Next up: C codegen...\n",
      "Generating C code for 3-Ricci tensor (FD order=2) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 0.6 seconds. Next up: C codegen...\n",
      "Generating C code for 3-Ricci tensor (FD order=4) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 0.6 seconds. Next up: C codegen...\n",
      "Generating C code for 3-Ricci tensor (FD order=4) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 0.6 seconds. Next up: C codegen...\n",
      "Generating C code for 3-Ricci tensor (FD order=6) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for 3-Ricci tensor (Cartesian coords) in 0.6 seconds. Next up: C codegen...\n",
      "Generating C code for 3-Ricci tensor (FD order=8) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 0.7 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN_RHSs (FD order=4) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 0.7 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN_RHSs (FD order=6) (Cartesian coords)...Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 0.7 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN_RHSs (FD order=8) (Cartesian coords)...\n",
      "\n",
      "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 1.0 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN constraints (FD order=6) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 1.1 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN constraints (FD order=4) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 1.0 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN constraints (FD order=8) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 1.5 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN_RHSs (FD order=2) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for BSSN_RHSs (Cartesian coords) in 1.5 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN_RHSs (FD order=4) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 1.6 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN constraints (FD order=2) (Cartesian coords)...\n",
      "Finished generating symbolic expressions for BSSN constraints (Cartesian coords) in 1.8 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN constraints (FD order=4) (Cartesian coords)...\n",
      "Finished generating C code for BSSN constraints (FD order=2) (Cartesian coords) in 48.5 seconds.\n",
      "Finished generating C code for BSSN constraints (FD order=4) (Cartesian coords) in 50.1 seconds.\n",
      "Finished generating C code for BSSN constraints (FD order=4) (Cartesian coords) in 51.1 seconds.\n",
      "Finished generating C code for BSSN constraints (FD order=6) (Cartesian coords) in 53.2 seconds.\n",
      "Finished generating C code for BSSN constraints (FD order=8) (Cartesian coords) in 55.4 seconds.\n",
      "Finished generating C code for BSSN_RHSs (FD order=8) (Cartesian coords) in 102.2 seconds.\n",
      "Finished generating C code for BSSN_RHSs (FD order=2) (Cartesian coords) in 104.3 seconds.\n",
      "Finished generating C code for BSSN_RHSs (FD order=6) (Cartesian coords) in 105.7 seconds.\n",
      "Finished generating C code for BSSN_RHSs (FD order=4) (Cartesian coords) in 106.5 seconds.\n",
      "Finished generating C code for BSSN_RHSs (FD order=4) (Cartesian coords) in 109.9 seconds.\n",
      "Finished generating C code for 3-Ricci tensor (FD order=2) (Cartesian coords) in 120.6 seconds.\n",
      "Finished generating C code for 3-Ricci tensor (FD order=4) (Cartesian coords) in 120.6 seconds.\n",
      "Finished generating C code for 3-Ricci tensor (FD order=4) (Cartesian coords) in 120.8 seconds.\n",
      "Finished generating C code for 3-Ricci tensor (FD order=8) (Cartesian coords) in 128.9 seconds.\n",
      "Finished generating C code for 3-Ricci tensor (FD order=6) (Cartesian coords) in 132.9 seconds.\n"
     ]
    }
   ],
   "source": [
    "def master_func(arg):\n",
    "    enable_stress_energy = True\n",
    "    par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\",\"True\")\n",
    "    par.set_parval_from_str(\"reference_metric::rfm_precompute_Ccode_outdir\",\n",
    "                            os.path.join(BSSN_funcs[arg].thornname, \"src\", \"rfm_files/\"))\n",
    "    rfm.reference_metric()\n",
    "\n",
    "    if BSSN_funcs[arg].thornname == \"BaikalVacuum\":\n",
    "        enable_stress_energy = False\n",
    "    func_name_suffix = \"_\" + BSSN_funcs[arg].thornname\n",
    "    if BSSN_funcs[arg].fdorder is not None:\n",
    "        par.set_parval_from_str(\"finite_difference::FD_CENTDERIVS_ORDER\", BSSN_funcs[arg].fdorder)\n",
    "        func_name_suffix += \"_order_\" + str(BSSN_funcs[arg].fdorder)\n",
    "\n",
    "    if BSSN_funcs[arg].name.__name__ == \"add_BSSN_constraints_to_Cfunction_dict\":\n",
    "        ret = BSSN_funcs[arg].name(includes=[\"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"],\n",
    "                                   rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                   enable_stress_energy_source_terms=enable_stress_energy,\n",
    "                                   leave_Ricci_symbolic=False, output_H_only=False,\n",
    "                                   enable_rfm_precompute=True, enable_golden_kernels=False,\n",
    "                                   enable_SIMD=True, func_name_suffix=func_name_suffix)\n",
    "    elif BSSN_funcs[arg].name.__name__ == \"add_rhs_eval_to_Cfunction_dict\":\n",
    "        ret = BSSN_funcs[arg].name(includes=[\"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"],\n",
    "                                   rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                   enable_stress_energy_source_terms=enable_stress_energy,\n",
    "                                   enable_rfm_precompute=True, enable_golden_kernels=enable_golden_kernels,\n",
    "                                   enable_SIMD=True, ShiftCondition=ShiftCondition,\n",
    "                                   enable_KreissOliger_dissipation=True,\n",
    "                                   func_name_suffix=func_name_suffix)\n",
    "    elif BSSN_funcs[arg].name.__name__ == \"add_Ricci_eval_to_Cfunction_dict\":\n",
    "        ret = BSSN_funcs[arg].name(includes=[\"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"],\n",
    "                                   rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                   enable_rfm_precompute=True,  enable_golden_kernels=enable_golden_kernels,\n",
    "                                   enable_SIMD=True, func_name_suffix=func_name_suffix)\n",
    "    elif BSSN_funcs[arg].name.__name__ == \"add_enforce_detgammahat_constraint_to_Cfunction_dict\":\n",
    "        ret = BSSN_funcs[arg].name(includes=[\"math.h\", \"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"],\n",
    "                                   rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                   enable_rfm_precompute=True,\n",
    "                                   func_name_suffix=func_name_suffix)\n",
    "    else:\n",
    "        print(\"ERROR: DID NOT RECOGNIZE FUNCTION \" + BSSN_funcs[arg].name.__name__ + \"\\n\")\n",
    "        sys.exit(1)\n",
    "    return ret\n",
    "\n",
    "\n",
    "NRPyEnvVars = []\n",
    "raised_exception = False\n",
    "try:\n",
    "    if os.name == 'nt':\n",
    "        # It's a mess to get working in Windows, so we don't bother. :/\n",
    "        #  https://medium.com/@grvsinghal/speed-up-your-python-code-using-multiprocessing-on-windows-and-jupyter-or-ipython-2714b49d6fac\n",
    "        raise Exception(\"Parallel codegen currently not available in certain environments, e.g., Windows\")\n",
    "\n",
    "    # Step 2.d: Import the multiprocessing module.\n",
    "    import multiprocessing\n",
    "\n",
    "    # Step 2.e: Evaluate list of functions in parallel if possible;\n",
    "    #           otherwise fallback to serial evaluation:\n",
    "    pool = multiprocessing.Pool()\n",
    "    NRPyEnvVars.append(pool.map(master_func, range(len(BSSN_funcs))))\n",
    "    pool.terminate()\n",
    "    pool.join()\n",
    "except:\n",
    "    print(\"FAILED PARALLEL CODEGEN!\")\n",
    "    NRPyEnvVars = [] # Reset, as pickling/unpickling unnecessary for serial codegen (see next line)\n",
    "\n",
    "    # Steps 2.d-e, alternate: As fallback, evaluate functions in serial.\n",
    "    #       This will happen on Android and Windows systems\n",
    "    for i, func in enumerate(BSSN_funcs):\n",
    "        master_func(i)\n",
    "    raised_exception = True\n",
    "\n",
    "outCfunc_master_list = outC_function_master_list\n",
    "if not raised_exception:\n",
    "    outCfunc_master_list = unpickle_NRPy_env(NRPyEnvVars)\n",
    "    for el in outCfunc_master_list:\n",
    "        if el not in outC_function_master_list:  # in case there are duplicate funcs, which can happen\n",
    "            #                                      if finite_difference_functions = True\n",
    "            outC_function_master_list += [el]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='cclfiles'></a>\n",
    "\n",
    "# Step 4: ETK `ccl` file generation \\[Back to [top](#toc)\\]\n",
    "$$\\label{cclfiles}$$\n",
    "\n",
    "The Einstein Toolkit (ETK) ccl files contain runtime parameters (`param.ccl`), registered gridfunctions (`interface.ccl`), and function scheduling (`schedule.ccl`). As parameters and gridfunctions are registered with NRPy+ when the C-code kernels are generated, and this generation occurs on separate processes in parallel, we store the entire NRPy+ environment for *each* process. This results in a tremendous amount of duplication, which is sorted out next. Once all duplicated environment variables (e.g., registered gridfunctions) are removed, we replace the current NRPy+ environment with the new one, by setting `gri.glb_gridfcs_list[],par.glb_params_list[],par.glb_Cparams_list[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.808752Z",
     "iopub.status.busy": "2021-12-20T04:19:21.808360Z",
     "iopub.status.idle": "2021-12-20T04:19:21.817395Z",
     "shell.execute_reply": "2021-12-20T04:19:21.817885Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BaikalVacuum/src/finite_difference_functions.h'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Store all NRPy+ environment variables to file so NRPy+ environment from within this subprocess can be easily restored\n",
    "\n",
    "# Finally, output all functions needed for computing finite-difference stencils\n",
    "#   to thornname/src/finite_difference_functions.h\n",
    "# Note that output_finite_difference_functions_h() deletes all the FD functions from\n",
    "#   the Cfunction dictionary, so it can only be called once; we must copy the generated\n",
    "#   file to BaikalVacuum:\n",
    "fin.output_finite_difference_functions_h(os.path.join(\"Baikal\", \"src\"))\n",
    "shutil.copy(os.path.join(\"Baikal\", \"src\", \"finite_difference_functions.h\"),\n",
    "            os.path.join(\"BaikalVacuum\", \"src\", \"finite_difference_functions.h\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='paramccl'></a>\n",
    "\n",
    "## Step 4.a: `param.ccl`: specify free parameters within `BaikalETK` \\[Back to [top](#toc)\\]\n",
    "$$\\label{paramccl}$$\n",
    "\n",
    "All parameters necessary for the computation of the BSSN right-hand side (RHS) expressions are registered within NRPy+; we use this information to automatically generate `param.ccl`. NRPy+ also specifies default values for each parameter. \n",
    "\n",
    "More information on `param.ccl` syntax can be found in the [official Einstein Toolkit documentation](http://einsteintoolkit.org/usersguide/UsersGuidech12.html#x17-183000D2.3)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.828295Z",
     "iopub.status.busy": "2021-12-20T04:19:21.827471Z",
     "iopub.status.idle": "2021-12-20T04:19:21.829703Z",
     "shell.execute_reply": "2021-12-20T04:19:21.830687Z"
    }
   },
   "outputs": [],
   "source": [
    "def keep_param__return_type(paramtuple):\n",
    "    keep_param = True # We'll not set some parameters in param.ccl;\n",
    "                      #   e.g., those that should be #define'd like M_PI.\n",
    "    typestring = \"\"\n",
    "    # Separate thorns within the ETK take care of grid/coordinate parameters;\n",
    "    #   thus we ignore NRPy+ grid/coordinate parameters:\n",
    "    if paramtuple.module == \"grid\" or paramtuple.module == \"reference_metric\":\n",
    "        keep_param = False\n",
    "\n",
    "    partype = paramtuple.type\n",
    "    if partype == \"bool\":\n",
    "        typestring += \"BOOLEAN \"\n",
    "    elif partype == \"REAL\":\n",
    "        if paramtuple.defaultval != 1e300: # 1e300 is a magic value indicating that the C parameter should be mutable\n",
    "            typestring += \"CCTK_REAL \"\n",
    "        else:\n",
    "            keep_param = False\n",
    "    elif partype == \"int\":\n",
    "        typestring += \"CCTK_INT \"\n",
    "    elif partype == \"#define\":\n",
    "        keep_param = False\n",
    "    elif partype == \"char\":\n",
    "        # FIXME: char/string parameter types should in principle be supported\n",
    "        print(\"Error: parameter \"+paramtuple.module+\"::\"+paramtuple.parname+\n",
    "              \" has unsupported type: \\\"\"+ paramtuple.type + \"\\\"\")\n",
    "        sys.exit(1)\n",
    "    else:\n",
    "        print(\"Error: parameter \"+paramtuple.module+\"::\"+paramtuple.parname+\n",
    "              \" has unsupported type: \\\"\"+ paramtuple.type + \"\\\"\")\n",
    "        sys.exit(1)\n",
    "    return keep_param, typestring\n",
    "\n",
    "def output_param_ccl(ThornName=\"BaikalETK\"):\n",
    "    with open(os.path.join(ThornName,\"param.ccl\"), \"w\") as file:\n",
    "        file.write(\"\"\"\n",
    "# This param.ccl file was automatically generated by NRPy+.\n",
    "#   You are advised against modifying it directly; instead\n",
    "#   modify the Python code that generates it.\n",
    "\n",
    "shares: ADMBase   # Extends multiple ADMBase variables:\n",
    "\n",
    "EXTENDS CCTK_KEYWORD evolution_method \"evolution_method\"\n",
    "{\n",
    "  \"BaikalETK\" :: \"\"\n",
    "}\n",
    "\n",
    "EXTENDS CCTK_KEYWORD lapse_evolution_method \"lapse_evolution_method\"\n",
    "{\n",
    "  \"BaikalETK\" :: \"\"\n",
    "}\n",
    "\n",
    "EXTENDS CCTK_KEYWORD shift_evolution_method \"shift_evolution_method\"\n",
    "{\n",
    "  \"BaikalETK\" :: \"\"\n",
    "}\n",
    "\n",
    "EXTENDS CCTK_KEYWORD dtshift_evolution_method \"dtshift_evolution_method\"\n",
    "{\n",
    "  \"BaikalETK\" :: \"\"\n",
    "}\n",
    "\n",
    "EXTENDS CCTK_KEYWORD dtlapse_evolution_method \"dtlapse_evolution_method\"\n",
    "{\n",
    "  \"BaikalETK\" :: \"\"\n",
    "}\n",
    "\n",
    "restricted:\n",
    "\n",
    "CCTK_INT FD_order \"Finite-differencing order\"\n",
    "{\\n\"\"\".replace(\"BaikalETK\",ThornName))\n",
    "        FDorders = Baikal_FDorders_list\n",
    "        if ThornName == \"BaikalVacuum\":\n",
    "            FDorders = BaikalVacuum_FDorders_list\n",
    "        for order in FDorders:\n",
    "            file.write(\" \"+str(order)+\":\"+str(order)+\"   :: \\\"finite-differencing order = \"+str(order)+\"\\\"\\n\")\n",
    "        FDorder_default = 4\n",
    "        if FDorder_default not in FDorders:\n",
    "            print(\"WARNING: 4th-order FD kernel was not output!?! Changing default FD order to \"+str(FDorders[0]))\n",
    "            FDorder_default = FDorders[0]\n",
    "        file.write(\"} \"+str(FDorder_default)+ \"\\n\\n\") # choose 4th order by default, consistent with ML_BSSN\n",
    "        paramccl_str = \"\"\n",
    "        for i in range(len(par.glb_Cparams_list)):\n",
    "            # keep_param is a boolean indicating whether we should accept or reject\n",
    "            #    the parameter. singleparstring will contain the string indicating\n",
    "            #    the variable type.\n",
    "            keep_param, singleparstring = keep_param__return_type(par.glb_Cparams_list[i])\n",
    "\n",
    "            if keep_param:\n",
    "                parname = par.glb_Cparams_list[i].parname\n",
    "                partype = par.glb_Cparams_list[i].type\n",
    "                singleparstring += parname + \" \\\"\"+ parname +\" (see NRPy+ for parameter definition)\\\"\\n\"\n",
    "                singleparstring += \"{\\n\"\n",
    "                if partype != \"bool\":\n",
    "                    singleparstring += \" *:* :: \\\"All values accepted. NRPy+ does not restrict the allowed ranges of parameters yet.\\\"\\n\"\n",
    "                singleparstring += \"} \"+str(par.glb_Cparams_list[i].defaultval)+\"\\n\\n\"\n",
    "\n",
    "                paramccl_str += singleparstring\n",
    "        file.write(paramccl_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='interfaceccl'></a>\n",
    "\n",
    "## Step 4.b: `interface.ccl`: define needed gridfunctions; provide keywords denoting what this thorn provides and what it should inherit from other thorns \\[Back to [top](#toc)\\]\n",
    "$$\\label{interfaceccl}$$\n",
    "\n",
    "`interface.ccl` declares all gridfunctions and determines how `BaikalETK` interacts with other Einstein Toolkit thorns.\n",
    "\n",
    "The [official Einstein Toolkit (Cactus) documentation](http://einsteintoolkit.org/usersguide/UsersGuide.html) defines what must/should be included in an `interface.ccl` file [**here**](http://einsteintoolkit.org/usersguide/UsersGuidech12.html#x17-178000D2.2). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.840045Z",
     "iopub.status.busy": "2021-12-20T04:19:21.839736Z",
     "iopub.status.idle": "2021-12-20T04:19:21.841911Z",
     "shell.execute_reply": "2021-12-20T04:19:21.841214Z"
    }
   },
   "outputs": [],
   "source": [
    "# First construct lists of the basic gridfunctions used in NRPy+.\n",
    "#    Each type will be its own group in BaikalETK.\n",
    "evol_gfs_list    = []\n",
    "auxevol_gfs_list = []\n",
    "aux_gfs_list     = []\n",
    "for i in range(len(gri.glb_gridfcs_list)):\n",
    "    if gri.glb_gridfcs_list[i].gftype == \"EVOL\":\n",
    "        evol_gfs_list.append(   gri.glb_gridfcs_list[i].name+\"GF\")\n",
    "\n",
    "    if gri.glb_gridfcs_list[i].gftype == \"AUX\":\n",
    "        aux_gfs_list.append(    gri.glb_gridfcs_list[i].name+\"GF\")\n",
    "\n",
    "    if gri.glb_gridfcs_list[i].gftype == \"AUXEVOL\":\n",
    "        auxevol_gfs_list.append(gri.glb_gridfcs_list[i].name+\"GF\")\n",
    "\n",
    "# NRPy+'s finite-difference code generator assumes gridfunctions\n",
    "#    are alphabetized; not sorting may result in unnecessary\n",
    "#    cache misses.\n",
    "evol_gfs_list.sort()\n",
    "aux_gfs_list.sort()\n",
    "auxevol_gfs_list.sort()\n",
    "rhs_list = []\n",
    "for gf in evol_gfs_list:\n",
    "    rhs_list.append(gf.replace(\"GF\",\"\")+\"_rhsGF\")\n",
    "\n",
    "def output_interface_ccl(ThornName=\"BaikalETK\",enable_stress_energy_source_terms=False):\n",
    "    outstr = \"\"\"\n",
    "# This interface.ccl file was automatically generated by NRPy+.\n",
    "#   You are advised against modifying it directly; instead\n",
    "#   modify the Python code that generates it.\n",
    "\n",
    "# With \"implements\", we give our thorn its unique name.\n",
    "implements: BaikalETK\n",
    "\n",
    "# By \"inheriting\" other thorns, we tell the Toolkit that we\n",
    "#   will rely on variables/function that exist within those\n",
    "#   functions.\n",
    "inherits:   ADMBase Boundary Grid MethodofLines CoordGauge\\n\"\"\"\n",
    "    if enable_stress_energy_source_terms:\n",
    "        outstr += \"inherits:   TmunuBase\\n\"\n",
    "    # Need a raw string here due to all the backslashes:\n",
    "    outstr += r\"\"\"\n",
    "# Needed functions and #include's:\n",
    "USES INCLUDE: Symmetry.h\n",
    "USES INCLUDE: Boundary.h\n",
    "USES INCLUDE: Slicing.h\n",
    "\n",
    "# Needed Method of Lines function\n",
    "CCTK_INT FUNCTION MoLRegisterEvolvedGroup(CCTK_INT IN EvolvedIndex, \\\n",
    "                                          CCTK_INT IN RHSIndex)\n",
    "REQUIRES FUNCTION MoLRegisterEvolvedGroup\n",
    "\n",
    "# Needed Boundary Conditions function\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_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",
    "# Needed for EinsteinEvolve/NewRad outer boundary condition driver:\n",
    "CCTK_INT FUNCTION                         \\\n",
    "    NewRad_Apply                          \\\n",
    "        (CCTK_POINTER_TO_CONST IN cctkGH, \\\n",
    "         CCTK_REAL ARRAY IN var,          \\\n",
    "         CCTK_REAL ARRAY INOUT rhs,       \\\n",
    "         CCTK_REAL IN var0,               \\\n",
    "         CCTK_REAL IN v0,                 \\\n",
    "         CCTK_INT IN radpower)\n",
    "REQUIRES FUNCTION NewRad_Apply\n",
    "\n",
    "# Needed to convert ADM initial data into BSSN initial data (gamma extrapolation)\n",
    "CCTK_INT FUNCTION                         \\\n",
    "    ExtrapolateGammas                     \\\n",
    "        (CCTK_POINTER_TO_CONST IN cctkGH, \\\n",
    "         CCTK_REAL ARRAY INOUT var)\n",
    "REQUIRES FUNCTION ExtrapolateGammas\n",
    "\n",
    "# Tell the Toolkit that we want all gridfunctions\n",
    "#    to be visible to other thorns by using\n",
    "#    the keyword \"public\". Note that declaring these\n",
    "#    gridfunctions *does not* allocate memory for them;\n",
    "#    that is done by the schedule.ccl file.\n",
    "\n",
    "# FIXME: add info for symmetry conditions:\n",
    "#    https://einsteintoolkit.org/thornguide/CactusBase/SymBase/documentation.html\n",
    "public:\n",
    "\"\"\"\n",
    "\n",
    "    # Next we declare gridfunctions based on their corresponding gridfunction groups as registered within NRPy+\n",
    "    def output_list_of_gfs(gfs_list, description=\"User did not provide description\"):\n",
    "        gfs_list_parsed = []\n",
    "        for j in range(len(gfs_list)):\n",
    "            # Add all gridfunctions in the list...\n",
    "            gfs_list_parsed.append(gfs_list[j])\n",
    "            # Then remove T4UU gridfunction from list if enable_stress_energy_source_terms==False:\n",
    "            if \"T4UU\" in gfs_list_parsed[-1] and enable_stress_energy_source_terms==False:\n",
    "                del gfs_list_parsed[-1]\n",
    "        gfsstr = \"    \"\n",
    "        for j in range(len(gfs_list_parsed)):\n",
    "            gfsstr += gfs_list_parsed[j]\n",
    "            if j != len(gfs_list_parsed)-1:\n",
    "                gfsstr += \",\"  # This is a comma-separated list of gridfunctions\n",
    "            else:\n",
    "                gfsstr += \"\\n} \\\"\"+description+\"\\\"\\n\\n\"\n",
    "        return gfsstr\n",
    "    # First EVOL type:\n",
    "    outstr += \"CCTK_REAL evol_variables type = GF Timelevels=3\\n{\\n\"\n",
    "    outstr += output_list_of_gfs(evol_gfs_list, \"BSSN evolved gridfunctions\")\n",
    "    # Second EVOL right-hand-sides\n",
    "    outstr += \"CCTK_REAL evol_variables_rhs type = GF Timelevels=1 TAGS=\\'InterpNumTimelevels=1 prolongation=\\\"none\\\"\\'\\n{\\n\"\n",
    "    outstr += output_list_of_gfs(rhs_list, \"right-hand-side storage for BSSN evolved gridfunctions\")\n",
    "    # Then AUX type:\n",
    "    outstr += \"CCTK_REAL aux_variables type = GF Timelevels=3\\n{\\n\"\n",
    "    outstr += output_list_of_gfs(aux_gfs_list, \"Auxiliary gridfunctions for BSSN diagnostics\")\n",
    "    # Finally, AUXEVOL type:\n",
    "    outstr += \"CCTK_REAL auxevol_variables type = GF Timelevels=1 TAGS=\\'InterpNumTimelevels=1 prolongation=\\\"none\\\"\\'\\n{\\n\"\n",
    "    outstr += output_list_of_gfs(auxevol_gfs_list, \"Auxiliary gridfunctions needed for evaluating the BSSN RHSs\")\n",
    "\n",
    "    with open(os.path.join(ThornName, \"interface.ccl\"), \"w\") as file:\n",
    "        file.write(outstr.replace(\"BaikalETK\", ThornName))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='scheduleccl'></a>\n",
    "\n",
    "## Step 4.c: `schedule.ccl`: schedule all functions used within `BaikalETK`, specify data dependencies within said functions, and allocate memory for gridfunctions \\[Back to [top](#toc)\\]\n",
    "$$\\label{scheduleccl}$$\n",
    "\n",
    "Official documentation on constructing ETK `schedule.ccl` files is found [here](http://einsteintoolkit.org/usersguide/UsersGuidech12.html#x17-186000D2.4)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.849482Z",
     "iopub.status.busy": "2021-12-20T04:19:21.848928Z",
     "iopub.status.idle": "2021-12-20T04:19:21.851400Z",
     "shell.execute_reply": "2021-12-20T04:19:21.851082Z"
    }
   },
   "outputs": [],
   "source": [
    "def output_schedule_ccl(ThornName=\"BaikalETK\", enable_stress_energy_source_terms=False):\n",
    "    FDorders = Baikal_FDorders_list\n",
    "    if ThornName == \"BaikalVacuum\":\n",
    "        FDorders = BaikalVacuum_FDorders_list\n",
    "    outstr = \"\"\"\n",
    "# This schedule.ccl file was automatically generated by NRPy+.\n",
    "#   You are advised against modifying it directly; instead\n",
    "#   modify the Python code that generates it.\n",
    "\n",
    "# First allocate storage for one timelevel of ADMBase gridfunctions, which is the\n",
    "#    bare minimum needed by NRPy+. If another thorn (e.g., ADMBase itself) requests\n",
    "#    more timelevels of storage, Cactus automatically allocates the maximum requested.\n",
    "STORAGE: ADMBase::metric[1], ADMBase::curv[1], ADMBase::lapse[1], ADMBase::shift[1]\n",
    "\n",
    "# Next allocate storage for all 3 gridfunction groups used in BaikalETK\n",
    "STORAGE: evol_variables[3]     # Evolution variables\n",
    "STORAGE: evol_variables_rhs[1] # Variables storing right-hand-sides\n",
    "STORAGE: aux_variables[3]      # Diagnostics variables\n",
    "STORAGE: auxevol_variables[1]  # Single-timelevel storage of variables needed for evolutions.\n",
    "\n",
    "# The following scheduler is based on Lean/LeanBSSNMoL/schedule.ccl\n",
    "\n",
    "schedule Banner_BaikalETK at STARTUP\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: meta\n",
    "} \"Output ASCII art banner\"\n",
    "\n",
    "schedule RegisterSlicing_BaikalETK at STARTUP after Banner_BaikalETK\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: meta\n",
    "} \"Register 3+1 slicing condition\"\n",
    "\n",
    "schedule Symmetry_registration_oldCartGrid3D_BaikalETK at BASEGRID\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: Global\n",
    "} \"Register symmetries, the CartGrid3D way.\"\n",
    "\n",
    "schedule zero_rhss_BaikalETK at BASEGRID after Symmetry_registration_oldCartGrid3D_BaikalETK\n",
    "{\n",
    "  LANG: C\n",
    "} \"Idea from Lean: set all rhs functions to zero to prevent spurious nans\"\n",
    "\n",
    "schedule ADM_to_BSSN_BaikalETK at CCTK_INITIAL after ADMBase_PostInitial\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: Local\n",
    "  SYNC: evol_variables\n",
    "} \"Convert initial data into BSSN variables\"\n",
    "\n",
    "schedule GROUP ApplyBCs as BaikalETK_ApplyBCs at CCTK_INITIAL after ADM_to_BSSN_BaikalETK\n",
    "{\n",
    "} \"Apply boundary conditions\"\n",
    "\n",
    "\n",
    "# MoL: registration\n",
    "\n",
    "schedule MoL_registration_BaikalETK in MoL_Register\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: META\n",
    "} \"Register variables for MoL\"\n",
    "\n",
    "\n",
    "# MoL: compute RHSs, etc\n",
    "\"\"\"\n",
    "    if enable_stress_energy_source_terms == True:\n",
    "        outstr += \"\"\"\n",
    "schedule T4DD_to_T4UU_BaikalETK in MoL_CalcRHS as BaikalETK_T4UU before BSSN_to_ADM_BaikalETK\n",
    "{\n",
    "  LANG: C\n",
    "} \"MoL: Compute T4UU from T4DD (provided in eT?? from TmunuBase), needed for BSSN RHSs.\"\n",
    "\"\"\"\n",
    "    for order in FDorders:\n",
    "        outstr += \"\"\"\n",
    "if(FD_order == \"\"\"+str(order)+\"\"\") {\n",
    "  schedule Ricci_eval_BaikalETK_order_\"\"\"+str(order)+\"\"\" in MoL_CalcRHS as BaikalETK_Ricci before BaikalETK_RHS\n",
    "  {\n",
    "    LANG: C\n",
    "  } \"MoL: Compute Ricci tensor, needed for BSSN RHSs, at finite-differencing order: \"\"\"+str(order)+\"\"\"\"\n",
    "\n",
    "  schedule rhs_eval_BaikalETK_order_\"\"\"+str(order)+\"\"\" in MoL_CalcRHS as BaikalETK_RHS after BaikalETK_Ricci\n",
    "  {\n",
    "    LANG: C\n",
    "  } \"MoL: Evaluate BSSN RHSs, at finite-differencing order: \"\"\"+str(order)+\"\"\"\"\n",
    "}\"\"\"\n",
    "    outstr += \"\"\"\n",
    "schedule specify_NewRad_BoundaryConditions_parameters_BaikalETK in MoL_CalcRHS after BaikalETK_RHS\n",
    "{\n",
    "  LANG: C\n",
    "} \"NewRad boundary conditions, scheduled right after RHS eval.\"\n",
    "\n",
    "schedule floor_the_lapse_BaikalETK in MoL_PostStep before enforce_detgammahat_constraint_BaikalETK before BC_Update\n",
    "{\n",
    "  LANG: C\n",
    "} \"Set lapse = max(lapse_floor, lapse)\"\n",
    "\n",
    "schedule enforce_detgammahat_constraint_BaikalETK in MoL_PostStep before BC_Update\n",
    "{\n",
    "  LANG: C\n",
    "} \"Enforce detgammabar = detgammahat (= 1 in Cartesian)\"\n",
    "\n",
    "schedule specify_BoundaryConditions_evolved_gfs_BaikalETK in MoL_PostStep\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: LEVEL\n",
    "  SYNC: evol_variables\n",
    "} \"Apply boundary conditions and perform AMR+interprocessor synchronization\"\n",
    "\n",
    "schedule GROUP ApplyBCs as BaikalETK_ApplyBCs in MoL_PostStep after specify_BoundaryConditions_evolved_gfs_BaikalETK\n",
    "{\n",
    "} \"Group for applying boundary conditions\"\n",
    "\n",
    "\n",
    "# Next update ADM quantities\n",
    "\n",
    "schedule BSSN_to_ADM_BaikalETK in MoL_PostStep after BaikalETK_ApplyBCs before ADMBase_SetADMVars\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: Local\n",
    "} \"Perform BSSN-to-ADM conversion. Useful for diagnostics.\"\n",
    "\n",
    "# Compute Hamiltonian & momentum constraints\n",
    "\"\"\"\n",
    "    if enable_stress_energy_source_terms == True:\n",
    "        outstr += \"\"\"\n",
    "schedule T4DD_to_T4UU_BaikalETK in MoL_PseudoEvolution before BaikalETK_BSSN_constraints\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: Local\n",
    "} \"MoL_PseudoEvolution: Compute T4UU from T4DD (provided in eT?? from TmunuBase), needed for BSSN constraints\"\n",
    "\"\"\"\n",
    "    for order in FDorders:\n",
    "        outstr += \"\"\"\n",
    "if(FD_order == \"\"\"+str(order)+\"\"\") {\n",
    "  schedule BSSN_constraints_BaikalETK_order_\"\"\"+str(order)+\"\"\" as BaikalETK_BSSN_constraints in MoL_PseudoEvolution\n",
    "  {\n",
    "    LANG: C\n",
    "    OPTIONS: Local\n",
    "  } \"Compute BSSN (Hamiltonian and momentum) constraints, at finite-differencing order: \"\"\"+str(order)+\"\"\"\"\n",
    "}\n",
    "\"\"\"\n",
    "    outstr += \"\"\"\n",
    "schedule specify_BoundaryConditions_aux_gfs_BaikalETK in MoL_PseudoEvolution after BaikalETK_BSSN_constraints\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: LEVEL\n",
    "  SYNC: aux_variables\n",
    "} \"Enforce symmetry BCs in constraint computation\"\n",
    "\n",
    "\"\"\"\n",
    "    if enable_stress_energy_source_terms == True:\n",
    "        outstr += \"\"\"\n",
    "schedule BSSN_to_ADM_BaikalETK in MoL_PseudoEvolution after specify_BoundaryConditions_aux_gfs_BaikalETK\n",
    "{\n",
    "  LANG: C\n",
    "  OPTIONS: Local\n",
    "} \"Perform BSSN-to-ADM conversion in MoL_PseudoEvolution. Needed for proper HydroBase integration.\"\n",
    "\"\"\"\n",
    "    outstr += \"\"\"\n",
    "schedule GROUP ApplyBCs as BaikalETK_auxgfs_ApplyBCs in MoL_PseudoEvolution after specify_BoundaryConditions_aux_gfs_BaikalETK\n",
    "{\n",
    "} \"Apply boundary conditions\"\n",
    "\"\"\"\n",
    "    with open(os.path.join(ThornName, \"schedule.ccl\"), \"w\") as file:\n",
    "        file.write(outstr.replace(\"BaikalETK\", ThornName))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='cdrivers'></a>\n",
    "\n",
    "# Step 5: Generate library of C functions needed for interfacing with the `Einstein Toolkit` \\[Back to [top](#toc)\\]\n",
    "$$\\label{cdrivers}$$\n",
    "\n",
    "Now that we have constructed the basic C code kernels and the needed Einstein Toolkit `ccl` files, we next write the driver functions for registering `Baikal`/`BaikalVacuum` within the Toolkit and the C code kernels. Each of these driver functions will be called directly from the thorn's [`schedule.ccl`](#scheduleccl) in the ETK.\n",
    "\n",
    "<a id='etkfunctions'></a>\n",
    "## Step 5.a: Needed ETK functions: Banner, Symmetry registration, Parameter sanity check,  Method of Lines (`MoL`) registration, Boundary condition registration \\[Back to [top](#toc)\\]\n",
    "$$\\label{etkfunctions}$$\n",
    "\n",
    "### To-do: Parameter sanity check function. E.g., error should be thrown if `cctk_nghostzones[]` is set too small for the chosen finite-differencing order within NRPy+."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.856161Z",
     "iopub.status.busy": "2021-12-20T04:19:21.855511Z",
     "iopub.status.idle": "2021-12-20T04:19:21.858761Z",
     "shell.execute_reply": "2021-12-20T04:19:21.857868Z"
    }
   },
   "outputs": [],
   "source": [
    "import NRPy_logo as logo\n",
    "# First the ETK banner code, proudly showing the NRPy+ banner\n",
    "def add_to_Cfunction_dict_Banner(ThornName):\n",
    "    logostr = logo.print_logo(print_to_stdout=False)\n",
    "    body = \"  printf(\\\"BaikalETK: another Einstein Toolkit thorn generated by\\\\n\\\");\\n\"\n",
    "    for line in logostr.splitlines():\n",
    "        body += \"  printf(\\\"\"+line+\"\\\\n\\\");\\n\"\n",
    "\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=[\"stdio.h\"],\n",
    "        desc=\"Output banner for NRPy+-generated thorn \" + ThornName,\n",
    "        c_type=\"void\", name=\"Banner_\" + ThornName, params=\"\",\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.864026Z",
     "iopub.status.busy": "2021-12-20T04:19:21.863000Z",
     "iopub.status.idle": "2021-12-20T04:19:21.865093Z",
     "shell.execute_reply": "2021-12-20T04:19:21.865465Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_RegisterSlicing(ThornName):\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=[\"cctk.h\", \"Slicing.h\"],\n",
    "        desc=\"Register slicing condition for NRPy+-generated thorn \" + ThornName,\n",
    "        c_type=\"int\", name=\"RegisterSlicing_\" + ThornName, params=\"\",\n",
    "        body=r\"\"\"  Einstein_RegisterSlicing (\"BaikalETK\");\n",
    "  return 0;\n",
    "\"\"\".replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.874229Z",
     "iopub.status.busy": "2021-12-20T04:19:21.873515Z",
     "iopub.status.idle": "2021-12-20T04:19:21.875657Z",
     "shell.execute_reply": "2021-12-20T04:19:21.875170Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_Symmetry_registration_oldCartGrid3D(ThornName):\n",
    "    enable_stress_energy_source_terms = True\n",
    "    if ThornName == \"BaikalVacuum\":\n",
    "        enable_stress_energy_source_terms = False\n",
    "    # Next Symmetry_registration_BaikalETK(): Register symmetries\n",
    "    includes = [\"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\", \"Symmetry.h\"]\n",
    "    desc = \"Register symmetries for NRPy+-generated thorn \" + ThornName\n",
    "    c_type = \"void\"\n",
    "    name = \"Symmetry_registration_oldCartGrid3D_\" + ThornName\n",
    "    params = \"CCTK_ARGUMENTS\"\n",
    "    full_gfs_list = []\n",
    "    full_gfs_list.extend(evol_gfs_list)\n",
    "    full_gfs_list.extend(auxevol_gfs_list)\n",
    "    full_gfs_list.extend(aux_gfs_list)\n",
    "    body = r\"\"\"  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\n",
    "  // Stores gridfunction parity across x=0, y=0, and z=0 planes, respectively\n",
    "  int sym[3];\n",
    "\n",
    "  // Next register parities for each gridfunction based on its name\n",
    "  //    (to ensure this algorithm is robust, gridfunctions with integers\n",
    "  //     in their base names are forbidden in NRPy+).\n",
    "\"\"\"\n",
    "    body += \"\"\n",
    "    for gfname in full_gfs_list:\n",
    "        gfname_without_GFsuffix = gfname[:-2]\n",
    "        # Do not add T4UU gridfunctions if enable_stress_energy_source_terms==False:\n",
    "        if not (enable_stress_energy_source_terms == False and \"T4UU\" in gfname_without_GFsuffix):\n",
    "            body += \"\"\"\n",
    "  // Default to scalar symmetry:\n",
    "  sym[0] = 1; sym[1] = 1; sym[2] = 1;\n",
    "  // Now modify sym[0], sym[1], and/or sym[2] as needed\n",
    "  //    to account for gridfunction parity across\n",
    "  //    x=0, y=0, and/or z=0 planes, respectively\n",
    "\"\"\"\n",
    "            # If gridfunction name does not end in a digit, by NRPy+ syntax, it must be a scalar\n",
    "            if gfname_without_GFsuffix[len(gfname_without_GFsuffix) - 1].isdigit() == False:\n",
    "                body += \"  // (this gridfunction is a scalar -- no need to change default sym[]'s!)\\n\"\n",
    "            elif len(gfname_without_GFsuffix) > 2:\n",
    "                # Rank-1 indexed expression (e.g., vector)\n",
    "                if gfname_without_GFsuffix[len(gfname_without_GFsuffix) - 2].isdigit() == False:\n",
    "                    if int(gfname_without_GFsuffix[-1]) > 2:\n",
    "                        print(\"Error: Found invalid gridfunction name: \"+gfname)\n",
    "                        sys.exit(1)\n",
    "                    symidx = gfname_without_GFsuffix[-1]\n",
    "                    if int(symidx) < 3:   body += \"  sym[\" + symidx + \"] = -1;\\n\"\n",
    "                # Rank-2 indexed expression\n",
    "                elif gfname_without_GFsuffix[len(gfname_without_GFsuffix) - 2].isdigit() == True:\n",
    "                    if len(gfname_without_GFsuffix) > 3 and gfname_without_GFsuffix[len(gfname_without_GFsuffix) - 3].isdigit() == True:\n",
    "                        print(\"Error: Found a Rank-3 or above gridfunction: \"+gfname+\", which is at the moment unsupported.\")\n",
    "                        print(\"It should be easy to support this if desired.\")\n",
    "                        sys.exit(1)\n",
    "                    symidx0 = gfname_without_GFsuffix[-2]\n",
    "                    if \"T4UU\" in gfname: symidx0 = str(int(symidx0)-1) # E.g., T4UU23 is T4UUyz, corresponding to directions 1,2\n",
    "                    if int(symidx0) >= 0: body += \"  sym[\" + symidx0 + \"] *= -1;\\n\"\n",
    "                    symidx1 = gfname_without_GFsuffix[-1]\n",
    "                    if \"T4UU\" in gfname: symidx1 = str(int(symidx1)-1) # E.g., T4UU23 is T4UUyz, corresponding to directions 1,2\n",
    "                    if int(symidx1) >= 0: body += \"  sym[\" + symidx1 + \"] *= -1;\\n\"\n",
    "            else:\n",
    "                print(\"Don't know how you got this far with a gridfunction named \"+gfname+\", but I'll take no more of this nonsense.\")\n",
    "                print(\"   Please follow best-practices and rename your gridfunction to be more descriptive\")\n",
    "                sys.exit(1)\n",
    "            body += \"  SetCartSymVN(cctkGH, sym, \\\"BaikalETK::\" + gfname + \"\\\");\\n\"\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.882318Z",
     "iopub.status.busy": "2021-12-20T04:19:21.881552Z",
     "iopub.status.idle": "2021-12-20T04:19:21.883536Z",
     "shell.execute_reply": "2021-12-20T04:19:21.883267Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_zero_rhss(ThornName):\n",
    "    # Next zero_rhss_BaikalETK(): initialize RHSs of gridfunctions to zero.\n",
    "    #  TODO: should probably set to NaN.\n",
    "    includes = [\"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"]\n",
    "    desc = \"Zero RHSs for NRPy+-generated thorn \" + ThornName\n",
    "    c_type = \"void\"\n",
    "    name = \"zero_rhss_\" + ThornName\n",
    "    params = \"CCTK_ARGUMENTS\"\n",
    "    body = r\"\"\"  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\"\"\"\n",
    "    set_rhss_to_zero = \"\"\n",
    "    for gf in rhs_list:\n",
    "        set_rhss_to_zero += gf+\"[CCTK_GFINDEX3D(cctkGH,i0,i1,i2)] = 0.0;\\n\"\n",
    "    set_rhss_to_zero = set_rhss_to_zero[:-1]\n",
    "    body += lp.loop([\"i2\",\"i1\",\"i0\"],[\"0\", \"0\", \"0\"],\n",
    "                    [\"cctk_lsh[2]\",\"cctk_lsh[1]\",\"cctk_lsh[0]\"],\n",
    "                    [\"1\",\"1\",\"1\"],\n",
    "                    [\"#pragma omp parallel for\",\"\",\"\",],padding=\"  \",interior=set_rhss_to_zero)\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.888461Z",
     "iopub.status.busy": "2021-12-20T04:19:21.887805Z",
     "iopub.status.idle": "2021-12-20T04:19:21.890088Z",
     "shell.execute_reply": "2021-12-20T04:19:21.889541Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_floor_the_lapse(ThornName):\n",
    "    # Register the C parameter for the lapse floor.\n",
    "    _lap_floor = par.Cparameters(\"REAL\", ThornName, \"lapse_floor\", 1e-15)\n",
    "\n",
    "    includes = [\"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"]\n",
    "    desc = \"Floor the lapse\"\n",
    "    c_type = \"void\"\n",
    "    name = \"floor_the_lapse_\" + ThornName\n",
    "    params = \"CCTK_ARGUMENTS\"\n",
    "    body = r\"\"\"  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\n",
    "#ifndef MAX\n",
    "#define MAX(a,b) ( ((a) > (b)) ? (a) : (b) )\n",
    "\n",
    "\"\"\"\n",
    "    body += lp.loop([\"i2\",\"i1\",\"i0\"],[\"0\", \"0\", \"0\"],\n",
    "                      [\"cctk_lsh[2]\",\"cctk_lsh[1]\",\"cctk_lsh[0]\"],\n",
    "                      [\"1\",\"1\",\"1\"],\n",
    "                      [\"#pragma omp parallel for\",\"\",\"\",],padding=\"  \",\n",
    "                    interior=\"\"\"alphaGF[CCTK_GFINDEX3D(cctkGH, i0,i1,i2)] = MAX(alphaGF[CCTK_GFINDEX3D(cctkGH, i0,i1,i2)], lapse_floor);\"\"\")\n",
    "    body += \"\"\"\n",
    "#undef MAX\n",
    "#endif\n",
    "\"\"\"\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.896225Z",
     "iopub.status.busy": "2021-12-20T04:19:21.895579Z",
     "iopub.status.idle": "2021-12-20T04:19:21.898284Z",
     "shell.execute_reply": "2021-12-20T04:19:21.897583Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_MoL_registration(ThornName):\n",
    "    # Next register gridfunctions with MoL\n",
    "    includes = [\"stdio.h\", \"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"]\n",
    "    desc = \"\"\"Register evolved gridfunctions & RHSs\n",
    "with the Method of Lines timestepper\n",
    "MoL (the Einstein Toolkit Method of Lines thorn)\n",
    "(MoL thorn, found in arrangements/CactusBase/MoL).\n",
    "MoL documentation located in arrangements/CactusBase/MoL/doc\n",
    "\"\"\"\n",
    "    c_type = \"void\"\n",
    "    name = \"MoL_registration_\" + ThornName\n",
    "    params = \"CCTK_ARGUMENTS\"\n",
    "    body = r\"\"\"  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\n",
    "  CCTK_INT ierr = 0, group, rhs;\n",
    "\n",
    "  // Register evolution & RHS gridfunction groups with MoL, so it knows\n",
    "  //  how to perform the appropriate timestepping\n",
    "\n",
    "  group = CCTK_GroupIndex(\"BaikalETK::evol_variables\");\n",
    "  rhs = CCTK_GroupIndex(\"BaikalETK::evol_variables_rhs\");\n",
    "  ierr += MoLRegisterEvolvedGroup(group, rhs);\n",
    "\n",
    "  if (ierr) CCTK_ERROR(\"Problems registering with MoL\");\n",
    "\"\"\"\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.903368Z",
     "iopub.status.busy": "2021-12-20T04:19:21.902981Z",
     "iopub.status.idle": "2021-12-20T04:19:21.905658Z",
     "shell.execute_reply": "2021-12-20T04:19:21.905072Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_specify_BoundaryConditions_evolved_gfs(ThornName):\n",
    "    includes = [\"stdio.h\", \"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"]\n",
    "    desc = \"\"\"Set `none` boundary conditions on BSSN evolved variables, as these are set via NewRad.\n",
    "\n",
    "Since we choose NewRad boundary conditions, we must register all\n",
    "  evolved gridfunctions to have boundary type \"none\". This is because\n",
    "  NewRad directly modifies the RHSs.\n",
    "\n",
    "This code is based on Kranc's McLachlan/ML_BSSN/src/Boundaries.cc code.\n",
    "\"\"\"\n",
    "    c_type = \"void\"\n",
    "    name = \"specify_BoundaryConditions_evolved_gfs_\" + ThornName\n",
    "    params = \"CCTK_ARGUMENTS\"\n",
    "    body = r\"\"\"  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "  CCTK_INT ierr CCTK_ATTRIBUTE_UNUSED = 0;\n",
    "\"\"\"\n",
    "    for gf in evol_gfs_list:\n",
    "        body += \"\"\"\n",
    "  ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, \"BaikalETK::\"\"\"+gf+\"\"\"\", \"none\");\n",
    "  if (ierr < 0) CCTK_ERROR(\"Failed to register BC for BaikalETK::\"\"\"+gf+\"\"\"!\");\n",
    "\"\"\"\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.912015Z",
     "iopub.status.busy": "2021-12-20T04:19:21.910939Z",
     "iopub.status.idle": "2021-12-20T04:19:21.913080Z",
     "shell.execute_reply": "2021-12-20T04:19:21.913881Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_specify_BoundaryConditions_aux_gfs(ThornName):\n",
    "    includes = [\"stdio.h\", \"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\",\n",
    "                \"cctk_Faces.h\", \"util_Table.h\"]\n",
    "    desc = \"\"\"Set `flat` boundary conditions on BSSN constraints, similar to what Lean does.\"\"\"\n",
    "    c_type = \"void\"\n",
    "    name = \"specify_BoundaryConditions_aux_gfs_\" + ThornName\n",
    "    params = \"CCTK_ARGUMENTS\"\n",
    "    body = r\"\"\"  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\n",
    "  CCTK_INT ierr CCTK_ATTRIBUTE_UNUSED = 0;\n",
    "\n",
    "  const CCTK_INT bndsize = FD_order / 2 + 1;  // <- bndsize = number of ghostzones\n",
    "\"\"\"\n",
    "    for gf in aux_gfs_list:\n",
    "        body += \"\"\"\n",
    "  ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, bndsize, -1, \"BaikalETK::\"\"\"+gf+\"\"\"\", \"flat\");\n",
    "  if (ierr < 0) CCTK_ERROR(\"Failed to register BC for BaikalETK::\"\"\"+gf+\"\"\"!\");\n",
    "\"\"\"\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.920453Z",
     "iopub.status.busy": "2021-12-20T04:19:21.920098Z",
     "iopub.status.idle": "2021-12-20T04:19:21.923636Z",
     "shell.execute_reply": "2021-12-20T04:19:21.923101Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_specify_NewRad_BoundaryConditions_parameters(ThornName):\n",
    "    includes = [\"math.h\", \"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"]\n",
    "    desc = \"\"\"\n",
    "Set up NewRad boundary conditions.\n",
    "   As explained in lean_public/LeanBSSNMoL/src/calc_bssn_rhs.F90,\n",
    "   the function NewRad_Apply takes the following arguments:\n",
    "   NewRad_Apply(cctkGH, var, rhs, var0, v0, radpower),\n",
    "     which implement the boundary condition:\n",
    "       var  =  var_at_infinite_r + u(r-var_char_speed*t)/r^var_radpower\n",
    "  Obviously for var_radpower>0, var_at_infinite_r is the value of\n",
    "    the variable at r->infinity. var_char_speed is the propagation\n",
    "    speed at the outer boundary, and var_radpower is the radial\n",
    "    falloff rate.\n",
    "\"\"\"\n",
    "    c_type = \"void\"\n",
    "    name = \"specify_NewRad_BoundaryConditions_parameters_\" + ThornName\n",
    "    params = \"CCTK_ARGUMENTS\"\n",
    "    body = r\"\"\"  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\n",
    "\"\"\"\n",
    "    for gf in evol_gfs_list:\n",
    "        var_at_infinite_r = \"0.0\"\n",
    "        var_char_speed    = \"1.0\"\n",
    "        for reg_gf in gri.glb_gridfcs_list:\n",
    "            if reg_gf.name+\"GF\" == gf:\n",
    "                var_at_infinite_r = str(reg_gf.f_infinity)\n",
    "                var_char_speed    = str(reg_gf.wavespeed)\n",
    "        var_radpower      = \"1.0\"\n",
    "        if \"aDD\" in gf or \"trK\" in gf: # consistent with Lean code.\n",
    "            var_radpower = \"2.0\"\n",
    "\n",
    "        body += \"  NewRad_Apply(cctkGH, \"+gf+\", \"+gf.replace(\"GF\",\"\")+\"_rhsGF, \"+var_at_infinite_r+\", \"+var_char_speed+\", \"+var_radpower+\");\\n\"\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='bssnadmconversions'></a>\n",
    "\n",
    "## Step 5.b: BSSN $\\leftrightarrow$ ADM conversions \\[Back to [top](#toc)\\]\n",
    "$$\\label{bssnadmconversions}$$\n",
    "\n",
    "<a id='admtobssn'></a>\n",
    "\n",
    "### Step 5.b.i: ADM $\\to$ BSSN \\[Back to [top](#toc)\\]\n",
    "$$\\label{admtobssn}$$\n",
    "\n",
    "Initial data in the Einstein Toolkit are given in terms of [ADM quantities](https://en.wikipedia.org/wiki/ADM_formalism), so a conversion is necessary so the quantities are in terms of BSSN variables used for evolving the initial data forward in time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.941855Z",
     "iopub.status.busy": "2021-12-20T04:19:21.940672Z",
     "iopub.status.idle": "2021-12-20T04:19:21.942942Z",
     "shell.execute_reply": "2021-12-20T04:19:21.943421Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_ADM_to_BSSN(ThornName):\n",
    "    includes = [\"math.h\", \"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"]\n",
    "    desc = \"\"\"Converting from ADM to BSSN quantities is required in the Einstein Toolkit,\n",
    "as initial data are given in terms of ADM quantities, and Baikal evolves the BSSN quantities.\"\"\"\n",
    "    c_type = \"void\"\n",
    "    name = \"ADM_to_BSSN_\" + ThornName\n",
    "    params = \"CCTK_ARGUMENTS\"\n",
    "\n",
    "    import BSSN.ADM_Numerical_Spherical_or_Cartesian_to_BSSNCurvilinear as atob\n",
    "    IDhDD,IDaDD,IDtrK,IDvetU,IDbetU,IDalpha,IDcf,IDlambdaU = \\\n",
    "        atob.Convert_Spherical_or_Cartesian_ADM_to_BSSN_curvilinear(\"Cartesian\",\"DoNotOutputADMInputFunction\",os.path.join(ThornName,\"src\"))\n",
    "\n",
    "    # Store the original list of registered gridfunctions; we'll want to unregister\n",
    "    #   all the *SphorCart* gridfunctions after we're finished with them below.\n",
    "    orig_glb_gridfcs_list = []\n",
    "    for gf in gri.glb_gridfcs_list:\n",
    "        orig_glb_gridfcs_list.append(gf)\n",
    "\n",
    "    # We ignore the return values for the following register_gridfunctions...() calls,\n",
    "    #   as they are unused.\n",
    "    gri.register_gridfunctions(                 \"AUXEVOL\", \"alphaSphorCart\")\n",
    "    ixp.register_gridfunctions_for_single_rank1(\"AUXEVOL\", \"betaSphorCartU\")\n",
    "    ixp.register_gridfunctions_for_single_rank1(\"AUXEVOL\", \"BSphorCartU\")\n",
    "    ixp.register_gridfunctions_for_single_rank2(\"AUXEVOL\", \"gammaSphorCartDD\", \"sym01\")\n",
    "    ixp.register_gridfunctions_for_single_rank2(\"AUXEVOL\", \"KSphorCartDD\", \"sym01\")\n",
    "\n",
    "    # ADM to BSSN conversion, used for converting ADM initial data into a form readable by this thorn.\n",
    "    # ADM to BSSN, Part 1: Set up function call and pointers to ADM gridfunctions\n",
    "    body = \"\"\"  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\n",
    "  CCTK_REAL *alphaSphorCartGF = alp;\n",
    "\"\"\"\n",
    "    # It's ugly if we output code in the following ordering, so we'll first\n",
    "    #   output to a string and then sort the string to beautify the code a bit.\n",
    "    outstrtmp = []\n",
    "    for i in range(3):\n",
    "        outstrtmp.append(\"  CCTK_REAL *betaSphorCartU\"+str(i)+\"GF = beta\"+chr(ord('x')+i)+\";\\n\")\n",
    "        outstrtmp.append(\"  CCTK_REAL *BSphorCartU\"+str(i)+\"GF = dtbeta\"+chr(ord('x')+i)+\";\\n\")\n",
    "        for j in range(i,3):\n",
    "            outstrtmp.append(\"  CCTK_REAL *gammaSphorCartDD\"+str(i)+str(j)+\"GF = g\"+chr(ord('x')+i)+chr(ord('x')+j)+\";\\n\")\n",
    "            outstrtmp.append(\"  CCTK_REAL *KSphorCartDD\"+str(i)+str(j)+\"GF = k\"+chr(ord('x')+i)+chr(ord('x')+j)+\";\\n\")\n",
    "    outstrtmp.sort()\n",
    "    for line in outstrtmp:\n",
    "        body += line\n",
    "\n",
    "    # ADM to BSSN, Part 2: Set up ADM to BSSN conversions for BSSN gridfunctions that do not require\n",
    "    #                      finite-difference derivatives (i.e., all gridfunctions except lambda^i (=Gamma^i\n",
    "    #                      in non-covariant BSSN)):\n",
    "    #                      h_{ij}, a_{ij}, trK, vet^i=beta^i,bet^i=B^i, cf (conformal factor), and alpha\n",
    "\n",
    "    # Output finite difference stencils as inlined expressions.\n",
    "    #   We do this instead of outputting as FD functions, as this function\n",
    "    #   does not take long to compile, and we have already output all the\n",
    "    #   FD functions to file, so if this one contains new FD functions,\n",
    "    #   the compile will fail.\n",
    "    par.set_parval_from_str(\"finite_difference::enable_FD_functions\", False)\n",
    "\n",
    "    all_but_lambdaU_expressions = [\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"hDD00\"), rhs=IDhDD[0][0]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"hDD01\"), rhs=IDhDD[0][1]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"hDD02\"), rhs=IDhDD[0][2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"hDD11\"), rhs=IDhDD[1][1]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"hDD12\"), rhs=IDhDD[1][2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"hDD22\"), rhs=IDhDD[2][2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"aDD00\"), rhs=IDaDD[0][0]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"aDD01\"), rhs=IDaDD[0][1]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"aDD02\"), rhs=IDaDD[0][2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"aDD11\"), rhs=IDaDD[1][1]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"aDD12\"), rhs=IDaDD[1][2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"aDD22\"), rhs=IDaDD[2][2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"trK\"), rhs=IDtrK),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"vetU0\"), rhs=IDvetU[0]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"vetU1\"), rhs=IDvetU[1]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"vetU2\"), rhs=IDvetU[2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"betU0\"), rhs=IDbetU[0]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"betU1\"), rhs=IDbetU[1]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"betU2\"), rhs=IDbetU[2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"alpha\"), rhs=IDalpha),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\", \"cf\"), rhs=IDcf)]\n",
    "\n",
    "    outCparams = \"preindent=0,outCfileaccess=a,outCverbose=False,includebraces=False\"\n",
    "    all_but_lambdaU_outC = fin.FD_outputC(\"returnstring\", all_but_lambdaU_expressions, outCparams)\n",
    "    body += lp.loop([\"i2\", \"i1\", \"i0\"], [\"0\", \"0\", \"0\"], [\"cctk_lsh[2]\", \"cctk_lsh[1]\", \"cctk_lsh[0]\"],\n",
    "                    [\"1\", \"1\", \"1\"], [\"#pragma omp parallel for\", \"\", \"\"], \"  \", all_but_lambdaU_outC)\n",
    "\n",
    "    # ADM to BSSN, Part 3: Set up ADM to BSSN conversions for BSSN gridfunctions defined from\n",
    "    #                      finite-difference derivatives: lambda^i, which is Gamma^i in non-covariant BSSN):\n",
    "    body += \"\"\"\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",
    "    BSSN_FD_orders = list(Baikal_FDorders_list)\n",
    "    if ThornName == \"BaikalVacuum\":\n",
    "        BSSN_FD_orders = list(BaikalVacuum_FDorders_list)\n",
    "\n",
    "    for FD_order in BSSN_FD_orders:\n",
    "        # Store original finite-differencing order:\n",
    "        orig_FD_order = par.parval_from_str(\"finite_difference::FD_CENTDERIVS_ORDER\")\n",
    "        # Set new finite-differencing order:\n",
    "        par.set_parval_from_str(\"finite_difference::FD_CENTDERIVS_ORDER\", FD_order)\n",
    "\n",
    "        outCparams = \"preindent=1,outCfileaccess=a,outCverbose=False,includebraces=False\"\n",
    "        lambdaU_expressions = [lhrh(lhs=gri.gfaccess(\"in_gfs\",\"lambdaU0\"),rhs=IDlambdaU[0]),\n",
    "                               lhrh(lhs=gri.gfaccess(\"in_gfs\",\"lambdaU1\"),rhs=IDlambdaU[1]),\n",
    "                               lhrh(lhs=gri.gfaccess(\"in_gfs\",\"lambdaU2\"),rhs=IDlambdaU[2])]\n",
    "        lambdaU_expressions_FDout = fin.FD_outputC(\"returnstring\",lambdaU_expressions, outCparams)\n",
    "\n",
    "        lambdakernel = 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]\",\"cctk_lsh[0]-cctk_nghostzones[0]\"],\n",
    "                               [\"1\",\"1\",\"1\"],[\"#pragma omp parallel for\",\"\",\"\"],padding=\"  \",\n",
    "                               interior=lambdaU_expressions_FDout)\n",
    "\n",
    "        body += \"  if(FD_order == \"+str(FD_order)+\") {\\n\"\n",
    "        body += indent_Ccode(lambdakernel)\n",
    "        body += \"  }\\n\"\n",
    "        # Restore original FD order\n",
    "        par.set_parval_from_str(\"finite_difference::FD_CENTDERIVS_ORDER\", orig_FD_order)\n",
    "\n",
    "    body += \"\"\"\n",
    "  ExtrapolateGammas(cctkGH, lambdaU0GF);\n",
    "  ExtrapolateGammas(cctkGH, lambdaU1GF);\n",
    "  ExtrapolateGammas(cctkGH, lambdaU2GF);\n",
    "\"\"\"\n",
    "\n",
    "    # Unregister the *SphorCartGF's.\n",
    "    gri.glb_gridfcs_list = orig_glb_gridfcs_list\n",
    "\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='bssntoadm'></a>\n",
    "\n",
    "### Step 5.b.ii: BSSN $\\to$ ADM \\[Back to [top](#toc)\\]\n",
    "$$\\label{bssntoadm}$$\n",
    "\n",
    "All modules (thorns) in the Einstein Toolkit that deal with spacetime quantities do so via the core `ADMBase` module, which assumes variables are written in ADM form. Therefore, in order for `BaikalETK` to interface properly with the rest of the Toolkit, its native BSSN variables must be converted to ADM quantities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.959287Z",
     "iopub.status.busy": "2021-12-20T04:19:21.958934Z",
     "iopub.status.idle": "2021-12-20T04:19:21.961105Z",
     "shell.execute_reply": "2021-12-20T04:19:21.960631Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_BSSN_to_ADM(ThornName):\n",
    "    includes = [\"math.h\", \"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"]\n",
    "    desc = \"\"\"Converting from ADM to BSSN quantities is required in the Einstein Toolkit,\n",
    "as initial data are given in terms of ADM quantities, and Baikal evolves the BSSN quantities.\"\"\"\n",
    "    c_type = \"void\"\n",
    "    name = \"BSSN_to_ADM_\" + ThornName\n",
    "    params = \"CCTK_ARGUMENTS\"\n",
    "\n",
    "    import BSSN.ADM_in_terms_of_BSSN as btoa\n",
    "    import BSSN.BSSN_quantities as Bq\n",
    "\n",
    "    btoa.ADM_in_terms_of_BSSN()\n",
    "    Bq.BSSN_basic_tensors() # Gives us betaU & BU\n",
    "\n",
    "    body = \"\"\"  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\"\"\"\n",
    "    btoa_lhrh = []\n",
    "    for i in range(3):\n",
    "        for j in range(i,3):\n",
    "            btoa_lhrh.append(lhrh(lhs=\"g\"+chr(ord('x')+i)+chr(ord('x')+j)+\"[CCTK_GFINDEX3D(cctkGH,i0,i1,i2)]\",\n",
    "                                  rhs=btoa.gammaDD[i][j]))\n",
    "    for i in range(3):\n",
    "        for j in range(i,3):\n",
    "            btoa_lhrh.append(lhrh(lhs=\"k\"+chr(ord('x')+i)+chr(ord('x')+j)+\"[CCTK_GFINDEX3D(cctkGH,i0,i1,i2)]\",\n",
    "                                  rhs=btoa.KDD[i][j]))\n",
    "    btoa_lhrh.append(lhrh(lhs=\"alp[CCTK_GFINDEX3D(cctkGH,i0,i1,i2)]\",rhs=Bq.alpha))\n",
    "\n",
    "    for i in range(3):\n",
    "        btoa_lhrh.append(lhrh(lhs=\"beta\"+chr(ord('x')+i)+\"[CCTK_GFINDEX3D(cctkGH,i0,i1,i2)]\",\n",
    "                                  rhs=Bq.betaU[i]))\n",
    "\n",
    "    for i in range(3):\n",
    "        btoa_lhrh.append(lhrh(lhs=\"dtbeta\"+chr(ord('x')+i)+\"[CCTK_GFINDEX3D(cctkGH,i0,i1,i2)]\",\n",
    "                                  rhs=Bq.BU[i]))\n",
    "\n",
    "    outCparams = \"preindent=0,outCfileaccess=a,outCverbose=False,includebraces=False\"\n",
    "    bssn_to_adm_Ccode = fin.FD_outputC(\"returnstring\",btoa_lhrh, outCparams)\n",
    "    body += lp.loop([\"i2\",\"i1\",\"i0\"],[\"0\",\"0\",\"0\"],[\"cctk_lsh[2]\",\"cctk_lsh[1]\",\"cctk_lsh[0]\"],\n",
    "                    [\"1\",\"1\",\"1\"],[\"#pragma omp parallel for\",\"\",\"\"],padding=\"  \",interior=bssn_to_adm_Ccode[:-1])\n",
    "\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='t4uu'></a>\n",
    "\n",
    "## Step 5.c: `T4DD_to_T4UU()`: Compute $T^{\\mu\\nu}$ from `TmunuBase`'s $T_{\\mu\\nu}$, using BSSN quantities as inputs for the 4D raising operation \\[Back to [top](#toc)\\]\n",
    "$$\\label{t4uu}$$\n",
    "\n",
    "Here we implement $T^{\\mu\\nu} = g^{\\mu \\delta} g^{\\nu \\gamma} T_{\\delta \\gamma}.$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.981190Z",
     "iopub.status.busy": "2021-12-20T04:19:21.980036Z",
     "iopub.status.idle": "2021-12-20T04:19:21.982533Z",
     "shell.execute_reply": "2021-12-20T04:19:21.981853Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_T4DD_to_T4UU(ThornName):\n",
    "    includes = [\"math.h\", \"cctk.h\", \"cctk_Arguments.h\", \"cctk_Parameters.h\"]\n",
    "    desc = \"\"\"Compute T4UU from T4DD (provided by TmunuBase),\n",
    "using BSSN quantities as inputs for the 4D raising operation\n",
    "\n",
    "WARNING: Do not enable SIMD here, as it is not guaranteed that\n",
    "         cctk_lsh[0]*cctk_lsh[1]*cctk_lsh[2] is a multiple of\n",
    "         SIMD_width!\n",
    "\"\"\"\n",
    "    c_type = \"void\"\n",
    "    name = \"T4DD_to_T4UU_\" + ThornName\n",
    "    params = \"CCTK_ARGUMENTS\"\n",
    "\n",
    "    # Declare T4DD as a set of gridfunctions. These won't\n",
    "    #    actually appear in interface.ccl, as interface.ccl\n",
    "    #    was set above. Thus before calling the code output\n",
    "    #    by FD_outputC(), we'll have to set pointers\n",
    "    #    to the actual gridfunctions they reference.\n",
    "    #    (In this case the eTab's.)\n",
    "    T4DD = ixp.register_gridfunctions_for_single_rank2(\"AUXEVOL\", \"T4DD\", \"sym01\", DIM=4)\n",
    "    import BSSN.ADMBSSN_tofrom_4metric as AB4m\n",
    "    AB4m.g4UU_ito_BSSN_or_ADM(\"BSSN\")\n",
    "\n",
    "    T4UUraised = ixp.zerorank2(DIM=4)\n",
    "    for mu in range(4):\n",
    "        for nu in range(4):\n",
    "            for delta in range(4):\n",
    "                for gamma in range(4):\n",
    "                    T4UUraised[mu][nu] += AB4m.g4UU[mu][delta]*AB4m.g4UU[nu][gamma]*T4DD[delta][gamma]\n",
    "\n",
    "    T4UU_expressions = [\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\",\"T4UU00\"),rhs=T4UUraised[0][0]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\",\"T4UU01\"),rhs=T4UUraised[0][1]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\",\"T4UU02\"),rhs=T4UUraised[0][2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\",\"T4UU03\"),rhs=T4UUraised[0][3]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\",\"T4UU11\"),rhs=T4UUraised[1][1]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\",\"T4UU12\"),rhs=T4UUraised[1][2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\",\"T4UU13\"),rhs=T4UUraised[1][3]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\",\"T4UU22\"),rhs=T4UUraised[2][2]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\",\"T4UU23\"),rhs=T4UUraised[2][3]),\n",
    "        lhrh(lhs=gri.gfaccess(\"in_gfs\",\"T4UU33\"),rhs=T4UUraised[3][3])]\n",
    "\n",
    "    outCparams = \"outCverbose=False,includebraces=False,preindent=0,enable_SIMD=False\"\n",
    "    T4UUstr = fin.FD_outputC(\"returnstring\",T4UU_expressions, outCparams)\n",
    "    T4UUstr_loop = lp.loop([\"i2\",\"i1\",\"i0\"],[\"0\",\"0\",\"0\"],[\"cctk_lsh[2]\",\"cctk_lsh[1]\",\"cctk_lsh[0]\"],\n",
    "                           [\"1\",\"1\",\"1\"],[\"#pragma omp parallel for\",\"\",\"\"],padding=\"  \",interior=T4UUstr)\n",
    "\n",
    "    body = r\"\"\"  DECLARE_CCTK_ARGUMENTS;\n",
    "  DECLARE_CCTK_PARAMETERS;\n",
    "\n",
    "  // First read in TmunuBase gridfunctions\n",
    "  const CCTK_REAL *restrict T4DD00GF = eTtt;\n",
    "  const CCTK_REAL *restrict T4DD01GF = eTtx;\n",
    "  const CCTK_REAL *restrict T4DD02GF = eTty;\n",
    "  const CCTK_REAL *restrict T4DD03GF = eTtz;\n",
    "  const CCTK_REAL *restrict T4DD11GF = eTxx;\n",
    "  const CCTK_REAL *restrict T4DD12GF = eTxy;\n",
    "  const CCTK_REAL *restrict T4DD13GF = eTxz;\n",
    "  const CCTK_REAL *restrict T4DD22GF = eTyy;\n",
    "  const CCTK_REAL *restrict T4DD23GF = eTyz;\n",
    "  const CCTK_REAL *restrict T4DD33GF = eTzz;\n",
    "\n",
    "  // TmunuBase provides T_{\\alpha \\beta}, but BSSN needs T^{\\alpha \\beta}.\n",
    "  //  Here we perform the raising operation using BSSN quantities as input:\n",
    "\"\"\" + T4UUstr_loop\n",
    "\n",
    "    # Now unregister T4DD gridfunctions\n",
    "    new_glb_gridfcs_list = []\n",
    "    for gf in gri.glb_gridfcs_list:\n",
    "        if \"T4DD\" not in gf.name:\n",
    "            new_glb_gridfcs_list += [gf]\n",
    "    gri.glb_gridfcs_list = list(new_glb_gridfcs_list)  # creates a copy!\n",
    "\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body.replace(\"BaikalETK\", ThornName),\n",
    "        enableCparameters=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='outcdrivers'></a>\n",
    "\n",
    "# Step 6: Output all C driver functions needed for `Baikal`/`BaikalVacuum` \\[Back to [top](#toc)\\]\n",
    "$$\\label{outcdrivers}$$\n",
    "\n",
    "First we call the above functions (output above to the `BaikalETK_validate.BaikalETK_C_drivers_codegen` Python module) to store all needed driver C files to a Python dictionary, then we simply outputs the dictionary to the appropriate files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:21.992199Z",
     "iopub.status.busy": "2021-12-20T04:19:21.991774Z",
     "iopub.status.idle": "2021-12-20T04:19:26.677588Z",
     "shell.execute_reply": "2021-12-20T04:19:26.676614Z"
    }
   },
   "outputs": [],
   "source": [
    "add_to_Cfunction_dict_T4DD_to_T4UU(\"Baikal\")  # BaikalVacuum does not deal with T4UU, as T4UU==zero in vacuum.\n",
    "for thorn in [\"Baikal\", \"BaikalVacuum\"]:\n",
    "    add_to_Cfunction_dict_ADM_to_BSSN(thorn)\n",
    "    add_to_Cfunction_dict_Banner(thorn)\n",
    "    add_to_Cfunction_dict_BSSN_to_ADM(thorn)\n",
    "    add_to_Cfunction_dict_floor_the_lapse(thorn)\n",
    "    add_to_Cfunction_dict_MoL_registration(thorn)\n",
    "    add_to_Cfunction_dict_RegisterSlicing(thorn)\n",
    "    add_to_Cfunction_dict_specify_BoundaryConditions_aux_gfs(thorn)\n",
    "    add_to_Cfunction_dict_specify_BoundaryConditions_evolved_gfs(thorn)\n",
    "    add_to_Cfunction_dict_specify_NewRad_BoundaryConditions_parameters(thorn)\n",
    "    add_to_Cfunction_dict_Symmetry_registration_oldCartGrid3D(thorn)\n",
    "    add_to_Cfunction_dict_zero_rhss(thorn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:26.684452Z",
     "iopub.status.busy": "2021-12-20T04:19:26.683643Z",
     "iopub.status.idle": "2021-12-20T04:19:26.686427Z",
     "shell.execute_reply": "2021-12-20T04:19:26.685630Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Output CCL files. This step depends on all Cparameters & gridfunctions being defined first.\n",
    "for enable_stress_energy_source_terms in [True, False]:\n",
    "    ThornName = \"BaikalVacuum\"\n",
    "    if enable_stress_energy_source_terms:\n",
    "        ThornName = \"Baikal\"\n",
    "    output_param_ccl(ThornName)\n",
    "    output_interface_ccl(ThornName, enable_stress_energy_source_terms)\n",
    "    output_schedule_ccl(ThornName, enable_stress_energy_source_terms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:26.692502Z",
     "iopub.status.busy": "2021-12-20T04:19:26.691979Z",
     "iopub.status.idle": "2021-12-20T04:19:26.697794Z",
     "shell.execute_reply": "2021-12-20T04:19:26.698190Z"
    }
   },
   "outputs": [],
   "source": [
    "from outputC import outC_function_dict\n",
    "\n",
    "def out_C_file(thorn, name):\n",
    "    with open(os.path.join(thorn, \"src\", name+\".c\"), \"w\") as Cfile:\n",
    "        Cfile.write(outC_function_dict[name])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='makecodedefn'></a>\n",
    "\n",
    "## Step 6.a: List all registered C files needed to compile `Baikal`/`BaikalVacuum` in `make.code.defn` \\[Back to [top](#toc)\\]\n",
    "$$\\label{makecodedefn}$$\n",
    "\n",
    "When registering each C function above, `outputC` stored the function to its `outC_function_master_list` list of named tuples. We'll now make use of `outC_function_master_list` to list each of those files in `Baikal`/`BaikalVacuum`'s `make.code.defn` file, needed by the Einstein Toolkit's build system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:26.692502Z",
     "iopub.status.busy": "2021-12-20T04:19:26.691979Z",
     "iopub.status.idle": "2021-12-20T04:19:26.697794Z",
     "shell.execute_reply": "2021-12-20T04:19:26.698190Z"
    }
   },
   "outputs": [],
   "source": [
    "# Finally, output [thornname]/src/make.code.defn\n",
    "for thorn in [\"Baikal\", \"BaikalVacuum\"]:\n",
    "    with open(os.path.join(thorn, \"src\", \"make.code.defn\"), \"w\") as file:\n",
    "        file.write(\"# Main make.code.defn file for thorn \" + thorn + \"\\n\\n\")\n",
    "        file.write(\"# Source files in this directory that need compiled:\\n\")\n",
    "        file.write(\"SRCS = \\\\\\n\")\n",
    "        outstr = \"\"\n",
    "        for item in outC_function_master_list:\n",
    "            if thorn == \"BaikalVacuum\":\n",
    "                if \"_\" + thorn in item.name:\n",
    "                    outstr += item.name + \".c \\\\\\n\"\n",
    "                    out_C_file(thorn, item.name)\n",
    "            else:\n",
    "                if \"_\" + thorn in item.name and not \"BaikalVacuum\" in item.name:\n",
    "                    outstr += item.name + \".c \\\\\\n\"\n",
    "                    out_C_file(thorn, item.name)\n",
    "        outstr = outstr[:-2] + \"\\n\"\n",
    "        file.write(indent_Ccode(outstr, \"       \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='code_validation'></a>\n",
    "\n",
    "# Step 7: Code validation \\[Back to [top](#toc)\\]\n",
    "$$\\label{code_validation}$$\n",
    "\n",
    "Here we will show plots demonstrating good agreement between `BaikalETK` and, e.g., `McLachlan` (another, trusted ETK thorn)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='self_validation'></a>\n",
    "\n",
    "## Step 7.a: Validation against [BaikalETK/](BaikalETK/) Python modules \\[Back to [top](#toc)\\]\n",
    "$$\\label{self_validation}$$\n",
    "\n",
    "As a self-validation check, we verify that the ETK thorns just generated here perfectly match those generated by the `BaikalETK.BaikalETK_main_codegen_driver` Python module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:26.710576Z",
     "iopub.status.busy": "2021-12-20T04:19:26.709595Z",
     "iopub.status.idle": "2021-12-20T04:19:26.711557Z",
     "shell.execute_reply": "2021-12-20T04:19:26.712351Z"
    }
   },
   "outputs": [],
   "source": [
    "# # First move the Baikal and Baikal_vacuum thorns just generated by this notebook to\n",
    "# #  the validate/ subdirectory:\n",
    "# shutil.rmtree(\"validate\", ignore_errors=True)\n",
    "# cmd.mkdir(\"validate\")\n",
    "# shutil.move(\"Baikal\",\"validate\")\n",
    "# shutil.move(\"BaikalVacuum\",\"validate\")\n",
    "\n",
    "# # Next generate Baikal and BaikalVacuum directly from the Python module.\n",
    "# #  These will output to the Baikal and BaikalVacuum directories.\n",
    "# !python3 BaikalETK/BaikalETK_main_codegen_driver.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:26.718181Z",
     "iopub.status.busy": "2021-12-20T04:19:26.717692Z",
     "iopub.status.idle": "2021-12-20T04:19:26.719290Z",
     "shell.execute_reply": "2021-12-20T04:19:26.719018Z"
    }
   },
   "outputs": [],
   "source": [
    "# # Then compare all files generated by this notebook\n",
    "# #      (output moved in previous code cell to validate/)\n",
    "# #      and the separate Python module (output to Baikal\n",
    "# #      and BaikalVacuum).\n",
    "# import difflib\n",
    "\n",
    "# def compare_two_files(filepath1,filepath2):\n",
    "#     with open(filepath1) as file1, open(filepath2) as file2:\n",
    "#         # Read the lines of each file\n",
    "#         file1_lines = file1.readlines()\n",
    "#         file2_lines = file2.readlines()\n",
    "#         num_diffs = 0\n",
    "#         file1_lines_noleadingwhitespace = []\n",
    "#         for line in file1_lines:\n",
    "#             if line.strip() == \"\": # If the line contains only whitespace, remove all leading whitespace\n",
    "#                 file1_lines_noleadingwhitespace.append(line.lstrip())\n",
    "#             else:\n",
    "#                 file1_lines_noleadingwhitespace.append(line)\n",
    "#         file2_lines_noleadingwhitespace = []\n",
    "#         for line in file2_lines:\n",
    "#             if line.strip() == \"\": # If the line contains only whitespace, remove all leading whitespace\n",
    "#                 file2_lines_noleadingwhitespace.append(line.lstrip())\n",
    "#             else:\n",
    "#                 file2_lines_noleadingwhitespace.append(line)\n",
    "#         for line in difflib.unified_diff(file1_lines_noleadingwhitespace, file2_lines_noleadingwhitespace,\n",
    "#                                          fromfile=filepath1,\n",
    "#                                          tofile  =filepath2):\n",
    "#             sys.stdout.writelines(line)\n",
    "#             num_diffs = num_diffs + 1\n",
    "#         if num_diffs == 0:\n",
    "#             print(\"PASSED: \"+filepath1+\" matches trusted version\")\n",
    "#         else:\n",
    "#             print(\"FAILED (see diff above): \"+filepath1+\" does NOT match trusted version\")\n",
    "\n",
    "# import os\n",
    "# for dirpath, dirnames, filenames in os.walk(\"validate\"):\n",
    "#     if len(filenames) > 1:\n",
    "#         filenames.sort()\n",
    "#         for file in [os.path.join(dirpath, file) for file in filenames]:\n",
    "#             compare_two_files(file,file.replace(os.path.join(\"validate/\"),\"\"))\n",
    "\n",
    "# # print(\"Ignoring lines with only whitespace:\")\n",
    "# # for file in [\"BaikalETK_C_drivers_codegen.py\",\"BaikalETK_C_kernels_codegen.py\",\"BaikalETK_ETK_ccl_files_codegen.py\"]:\n",
    "# #     compare_two_files(BaikalETKdir,\"BaikalETK\",file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='latex_pdf_output'></a>\n",
    "\n",
    "# Step 8: 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-BaikalETK.pdf](Tutorial-BaikalETK.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": 28,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-20T04:19:26.722166Z",
     "iopub.status.busy": "2021-12-20T04:19:26.721875Z",
     "iopub.status.idle": "2021-12-20T04:19:34.357797Z",
     "shell.execute_reply": "2021-12-20T04:19:34.357066Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created Tutorial-BaikalETK_new_way.tex, and compiled LaTeX file to PDF file\n",
      "    Tutorial-BaikalETK_new_way.pdf\n"
     ]
    }
   ],
   "source": [
    "import cmdline_helper as cmd    # NRPy+: Multi-platform Python command-line interface\n",
    "cmd.output_Jupyter_notebook_to_LaTeXed_PDF(\"Tutorial-BaikalETK_new_way\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}