Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide.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",
    "# Start-to-Finish Example: Head-On Black Hole Collision\n",
    "\n",
    "## Author: Zach Etienne\n",
    "### Formatting improvements courtesy Brandon Clark\n",
    "\n",
    "## This module implements a basic numerical relativity code to merge two black holes in *spherical coordinates*\n",
    "\n",
    "### Here we place the black holes initially on the $z$-axis, so the entire simulation is axisymmetric about the $\\phi$-axis. Not sampling in the $\\phi$ direction greatly speeds up the simulation.\n",
    "\n",
    "**Notebook Status:** <font color = green><b> Validated </b></font>\n",
    "\n",
    "**Validation Notes:** This module has been validated to exhibit convergence to zero of the Hamiltonian constraint violation at the expected order to the exact solution *after a short numerical evolution of the initial data* (see [plots at bottom](#convergence)), and all quantities have been validated against the [original SENR code](https://bitbucket.org/zach_etienne/nrpy).\n",
    "\n",
    "### NRPy+ Source Code & Tutorials for this module: \n",
    "* [BSSN/BrillLindquist.py](../edit/BSSN/BrillLindquist.py); [\\[**tutorial**\\]](Tutorial-ADM_Initial_Data-Brill-Lindquist.ipynb): Brill-Lindquist initial data; sets all ADM variables in Cartesian basis: \n",
    "* [BSSN/ADM_Initial_Data_Reader__BSSN_Converter.py](../edit/BSSN/ADM_Initial_Data_Reader__BSSN_Converter.py); [\\[**tutorial**\\]](Tutorial-ADM_Initial_Data_Reader__BSSN_Converter.ipynb): Registers the C function for our \"universal\" initial data reader/converter initial_data_reader__convert_ADM_Cartesian_to_BSSN().\n",
    "* [MoLtimestepping/MoL.py](../edit/MoLtimestepping/MoL.py); ([**NRPy+ Tutorial documentation**](Tutorial-Method_of_Lines-C_Code_Generation.ipynb)): Registers C functions for Method of Lines time integration, to push our initial data forward in time.\n",
    "* [CurviBoundaryConditions/CurviBoundaryConditions.py](../edit/CurviBoundaryConditions/CurviBoundaryConditions.py); [\\[**tutorial**\\]](Tutorial-Start_to_Finish-Curvilinear_BCs.ipynb): Registers the C function for our \"universal\" initial data reader/converter initial_data_reader__convert_ADM_Cartesian_to_BSSN(). This applies boundary conditions to BSSN quantities (including $\\lambda^i$, which is computed via finite difference derivatives and thus only defined in grid interior)\n",
    "* [BSSN/BSSN_Ccodegen_library.py](../edit/BSSN/BSSN_Ccodegen_library.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-C_codegen_library.ipynb): Implements a number of helper functions for generating C codes from symbolic expressions generated in the following modules/tutorials:\n",
    "    * [BSSN/BSSN_constraints.py](../edit/BSSN/BSSN_constraints.py); [\\[**tutorial**\\]](Tutorial-BSSN_constraints.ipynb): Hamiltonian constraint in BSSN curvilinear basis/coordinates\n",
    "    * [BSSN/BSSN_RHSs.py](../edit/BSSN/BSSN_RHSs.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_RHSs.ipynb): Generates the right-hand sides for the BSSN evolution equations in singular, curvilinear coordinates\n",
    "    * [BSSN/BSSN_gauge_RHSs.py](../edit/BSSN/BSSN_gauge_RHSs.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_gauge_RHSs.ipynb): Generates the right-hand sides for the BSSN gauge evolution equations in singular, curvilinear coordinates\n",
    "\n",
    "## Introduction:\n",
    "Here we use NRPy+ to generate the C source code necessary to set up initial data for two black holes (Brill-Lindquist, [Brill & Lindquist, Phys. Rev. 131, 471, 1963](https://journals.aps.org/pr/abstract/10.1103/PhysRev.131.471); see also Eq. 1 of [Brandt & Brügmann, arXiv:gr-qc/9711015v1](https://arxiv.org/pdf/gr-qc/9711015v1.pdf)). Then we use it to generate the RHS expressions for [Method of Lines](https://reference.wolfram.com/language/tutorial/NDSolveMethodOfLines.html) time integration based on an [explicit Runge-Kutta fourth-order scheme](https://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods) (RK4 is chosen below, but multiple options exist). \n",
    "\n",
    "The entire algorithm is outlined as follows, with links to the relevant NRPy+ tutorial notebooks listed at each step:\n",
    "\n",
    "1. Allocate memory for gridfunctions, including temporary storage for the Method of Lines time integration\n",
    "    * [**NRPy+ tutorial on Method of Lines algorithm**](Tutorial-Method_of_Lines-C_Code_Generation.ipynb).\n",
    "1. Set gridfunction values to initial data \n",
    "    * [**NRPy+ tutorial on Brill-Lindquist initial data**](Tutorial-ADM_Initial_Data-Brill-Lindquist.ipynb)\n",
    "    * [**NRPy+ tutorial on validating Brill-Lindquist initial data**](Tutorial-Start_to_Finish-BSSNCurvilinear-Exact_Initial_Data.ipynb).\n",
    "1. Next, integrate the initial data forward in time using the Method of Lines coupled to a Runge-Kutta explicit timestepping algorithm:\n",
    "    1. At the start of each iteration in time, output the Hamiltonian constraint violation \n",
    "        * [**NRPy+ tutorial on BSSN constraints**](Tutorial-BSSN_constraints.ipynb).\n",
    "    1. At each RK time substep, do the following:\n",
    "        1. Evaluate BSSN RHS expressions \n",
    "            * [**NRPy+ tutorial on BSSN right-hand sides**](Tutorial-BSSN_time_evolution-BSSN_RHSs.ipynb) ([**BSSN Introduction Notebook**](Tutorial-BSSN_formulation.ipynb))\n",
    "            * [**NRPy+ tutorial on BSSN gauge condition right-hand sides**](Tutorial-BSSN_time_evolution-BSSN_gauge_RHSs.ipynb) \n",
    "        1. Apply singular, curvilinear coordinate boundary conditions [*a la* the SENR/NRPy+ paper](https://arxiv.org/abs/1712.07658)\n",
    "            * [**NRPy+ tutorial on setting up singular, curvilinear boundary conditions**](Tutorial-Start_to_Finish-Curvilinear_BCs.ipynb)\n",
    "        1. Enforce constraint on conformal 3-metric: $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ \n",
    "            * [**NRPy+ tutorial on enforcing $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ constraint**](Tutorial-BSSN_enforcing_determinant_gammabar_equals_gammahat_constraint.ipynb)\n",
    "1. Repeat above steps at two numerical resolutions to confirm convergence to zero."
   ]
  },
  {
   "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): Set core NRPy+ parameters for numerical grids and reference metric\n",
    "1. [Step 2](#ccodegen): Generate C code kernels for BSSN expressions, in parallel if possible\n",
    "    1. [Step 2.a](#rfm_ccodegen): Generate C code kernels for reference metric\n",
    "1. [Step 3](#cparams_rfm_and_domainsize): Set `free_parameters.h`; also output C codes needed for declaring and setting Cparameters\n",
    "1. [Step 4](#bc_functs): Set up boundary condition functions for chosen singular, curvilinear coordinate system\n",
    "1. [Step 5](#mainc): `BrillLindquist_Playground`: The C code `main()` function\n",
    "1. [Step 6](#compileexec): Compile generated C codes & perform the black hole collision calculation\n",
    "1. [Step 7](#visualize): Visualize the output!\n",
    "    1. [Step 7.a](#installdownload): Install `scipy` and download `ffmpeg` if they are not yet installed/downloaded\n",
    "    1. [Step 7.b](#genimages): Generate images for visualization animation\n",
    "    1. [Step 7.c](#genvideo): Generate visualization animation\n",
    "1. [Step 8](#convergence): Plot the numerical error at the end of the simulation, and confirm that it converges to zero with increasing numerical resolution (sampling)\n",
    "1. [Step 9](#latex_pdf_output): Output this notebook to $\\LaTeX$-formatted PDF file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='initializenrpy'></a>\n",
    "\n",
    "# Step 1: Set core NRPy+ parameters for numerical grids and reference metric \\[Back to [top](#toc)\\]\n",
    "$$\\label{initializenrpy}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:25.778737Z",
     "iopub.status.busy": "2021-09-23T22:08:25.774943Z",
     "iopub.status.idle": "2021-09-23T22:08:26.199113Z",
     "shell.execute_reply": "2021-09-23T22:08:26.198629Z"
    }
   },
   "outputs": [],
   "source": [
    "# Step P1: Import needed NRPy+ core modules:\n",
    "from outputC import add_to_Cfunction_dict, outC_function_master_list  # NRPy+: Core C code output module\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 reference_metric as rfm   # NRPy+: Reference metric support\n",
    "import cmdline_helper as cmd     # NRPy+: Multi-platform Python command-line interface\n",
    "from pickling import unpickle_NRPy_env  # NRPy+: Pickle/unpickle NRPy+ environment, for parallel codegen\n",
    "import shutil, os, sys           # Standard Python modules for multiplatform OS-level functions, benchmarking\n",
    "\n",
    "# Step P2: Create C code output directory:\n",
    "Ccodesrootdir = os.path.join(\"BSSN_Two_BHs_Collide_Ccodes\")\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(Ccodesrootdir, ignore_errors=True)\n",
    "# Then create a fresh directory\n",
    "cmd.mkdir(Ccodesrootdir)\n",
    "\n",
    "# Step P3: Create executable output directory:\n",
    "outdir = os.path.join(Ccodesrootdir, \"output\")\n",
    "cmd.mkdir(outdir)\n",
    "\n",
    "# Step 1.a: Enable SIMD-optimized code?\n",
    "#           I.e., generate BSSN and Ricci C code kernels using SIMD-vectorized\n",
    "#           compiler intrinsics, which *greatly improve the code's performance*,\n",
    "#           though at the expense of making the C-code kernels less\n",
    "#           human-readable.\n",
    "#           * Important note in case you wish to modify the BSSN/Ricci kernels\n",
    "#             here by adding expressions containing transcendental functions\n",
    "#             (e.g., certain scalar fields):\n",
    "#           Note that SIMD-based transcendental function intrinsics are not\n",
    "#           supported by the default installation of gcc or clang (you will\n",
    "#           need to use e.g., the SLEEF library from sleef.org, for this\n",
    "#           purpose). The Intel compiler suite does support these intrinsics\n",
    "#           however without the need for external libraries.\n",
    "enable_SIMD = True\n",
    "\n",
    "# Step 1.b: Enable reference metric precomputation.\n",
    "enable_rfm_precompute = True\n",
    "\n",
    "if enable_SIMD and not enable_rfm_precompute:\n",
    "    print(\"ERROR: SIMD does not currently handle transcendental functions,\\n\")\n",
    "    print(\"       like those found in rfmstruct (rfm_precompute).\\n\")\n",
    "    print(\"       Therefore, enable_SIMD==True and enable_rfm_precompute==False\\n\")\n",
    "    print(\"       is not supported.\\n\")\n",
    "    sys.exit(1)\n",
    "\n",
    "# Step 1.c: Enable \"FD functions\". In other words, all finite-difference stencils\n",
    "#         will be output as inlined static functions. This is essential for\n",
    "#         compiling highly complex FD kernels with using certain versions of GCC;\n",
    "#         GCC 10-ish will choke on BSSN FD kernels at high FD order, sometimes\n",
    "#         taking *hours* to compile. Unaffected GCC versions compile these kernels\n",
    "#         in seconds. FD functions do not slow the code performance, but do add\n",
    "#         another header file to the C source tree.\n",
    "# With gcc 7.5.0, enable_FD_functions=True decreases performance by 10%\n",
    "enable_FD_functions = True\n",
    "\n",
    "# Step 2: Set some core parameters, including CoordSystem MoL timestepping algorithm,\n",
    "#                                 FD order, floating point precision, and CFL factor:\n",
    "# Choices are: Spherical, SinhSpherical, SinhSphericalv2, Cylindrical, SinhCylindrical,\n",
    "#              SymTP, SinhSymTP\n",
    "CoordSystem     = \"Spherical\"\n",
    "par.set_parval_from_str(\"reference_metric::CoordSystem\", CoordSystem)\n",
    "rfm.reference_metric()\n",
    "\n",
    "# Step 2.a: Set outer boundary condition\n",
    "outer_bc_type = \"RADIATION_OUTER_BCS\"  # can be EXTRAPOLATION_OUTER_BCS or RADIATION_OUTER_BCS\n",
    "radiation_BC_FD_order = 2\n",
    "\n",
    "# Step 2.b: Set defaults for Coordinate system parameters.\n",
    "#           These are perhaps the most commonly adjusted parameters,\n",
    "#           so we enable modifications at this high level.\n",
    "\n",
    "# domain_size sets the default value for:\n",
    "#   * Spherical's params.RMAX\n",
    "#   * SinhSpherical*'s params.AMAX\n",
    "#   * Cartesians*'s -params.{x,y,z}min & .{x,y,z}max\n",
    "#   * Cylindrical's -params.ZMIN & .{Z,RHO}MAX\n",
    "#   * SinhCylindrical's params.AMPL{RHO,Z}\n",
    "#   * *SymTP's params.AMAX\n",
    "domain_size     = 7.5 # Needed for all coordinate systems.\n",
    "\n",
    "# sinh_width sets the default value for:\n",
    "#   * SinhSpherical's params.SINHW\n",
    "#   * SinhCylindrical's params.SINHW{RHO,Z}\n",
    "#   * SinhSymTP's params.SINHWAA\n",
    "sinh_width      = 0.4 # If Sinh* coordinates chosen\n",
    "\n",
    "# sinhv2_const_dr sets the default value for:\n",
    "#   * SinhSphericalv2's params.const_dr\n",
    "#   * SinhCylindricalv2's params.const_d{rho,z}\n",
    "sinhv2_const_dr = 0.05 # If Sinh*v2 coordinates chosen\n",
    "\n",
    "# SymTP_bScale sets the default value for:\n",
    "#   * SinhSymTP's params.bScale\n",
    "SymTP_bScale    = 0.5 # If SymTP chosen\n",
    "\n",
    "# Step 2.c: Set the order of spatial and temporal derivatives;\n",
    "#           the core data type, and the CFL factor.\n",
    "# RK_method choices include: Euler, \"RK2 Heun\", \"RK2 MP\", \"RK2 Ralston\", RK3, \"RK3 Heun\", \"RK3 Ralston\",\n",
    "#              SSPRK3, RK4, DP5, DP5alt, CK5, DP6, L6, DP8\n",
    "RK_method = \"RK4\"\n",
    "FD_order  = 4            # Finite difference order: even numbers only, starting with 2. 12 is generally unstable\n",
    "REAL      = \"double\"     # Best to use double here.\n",
    "default_CFL_FACTOR= 0.5  # (GETS OVERWRITTEN IF SPECIFIED AT COMMAND LINE.)\n",
    "                         # In pure axisymmetry (symmetry_axes = 2 below) 1.0 works fine. Otherwise 0.5 or lower."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:26.203895Z",
     "iopub.status.busy": "2021-09-23T22:08:26.203369Z",
     "iopub.status.idle": "2021-09-23T22:08:26.205606Z",
     "shell.execute_reply": "2021-09-23T22:08:26.205163Z"
    }
   },
   "outputs": [],
   "source": [
    "# Step 5: Set the finite differencing order to FD_order (set above).\n",
    "par.set_parval_from_str(\"finite_difference::FD_CENTDERIVS_ORDER\", FD_order)\n",
    "\n",
    "# Directory for reference_metric precomputation header files:\n",
    "rfm_precompute_Ccode_outdir = os.path.join(Ccodesrootdir, \"rfm_files/\")\n",
    "if enable_rfm_precompute:\n",
    "    cmd.mkdir(os.path.join(Ccodesrootdir, \"rfm_files/\"))\n",
    "    par.set_parval_from_str(\"reference_metric::rfm_precompute_Ccode_outdir\", rfm_precompute_Ccode_outdir)\n",
    "\n",
    "# Step 6: Copy SIMD/SIMD_intrinsics.h to $Ccodesrootdir/SIMD/SIMD_intrinsics.h\n",
    "if enable_SIMD:\n",
    "    cmd.mkdir(os.path.join(Ccodesrootdir,\"SIMD\"))\n",
    "    shutil.copy(os.path.join(\"SIMD/\")+\"SIMD_intrinsics.h\",os.path.join(Ccodesrootdir,\"SIMD/\"))\n",
    "\n",
    "# Step 7: Set finite_difference::enable_FD_functions appropriately. Defaults to False\n",
    "if enable_FD_functions:\n",
    "    par.set_parval_from_str(\"finite_difference::enable_FD_functions\", enable_FD_functions)\n",
    "\n",
    "# Step 8: If enable_SIMD, then copy SIMD/SIMD_intrinsics.h to $Ccodesrootdir/SIMD/SIMD_intrinsics.h\n",
    "cmd.mkdir(os.path.join(Ccodesrootdir,\"SIMD\"))\n",
    "if enable_SIMD:\n",
    "    shutil.copy(os.path.join(\"SIMD\", \"SIMD_intrinsics.h\"), os.path.join(Ccodesrootdir, \"SIMD\"))\n",
    "\n",
    "# Step 9: Set the direction=2 (phi) axis to be the symmetry axis; i.e.,\n",
    "#         axis \"2\", corresponding to the i2 direction.\n",
    "#      This sets all spatial derivatives in the phi direction to zero.\n",
    "par.set_parval_from_str(\"indexedexp::symmetry_axes\",\"2\")\n",
    "OMP_pragma_on = \"i1\"  # structure OpenMP loops to parallelize, not over i2 (phi direction), but i1 (theta direction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 10: Generate Runge-Kutta-based (RK-based) timestepping code.\n",
    "#       As described above the Table of Contents, this is a 3-step process:\n",
    "#       10.A: Evaluate RHSs (RHS_string)\n",
    "#       10.B: Apply boundary conditions (post_RHS_string, pt 1)\n",
    "#       10.C: Enforce det(gammabar) = det(gammahat) constraint (post_RHS_string, pt 2)\n",
    "import MoLtimestepping.MoL as MoL\n",
    "# from MoLtimestepping.RK_Butcher_Table_Dictionary import Butcher_dict\n",
    "# RK_order  = Butcher_dict[RK_method][1]\n",
    "RHS_string      = \"\"\"\n",
    "Ricci_eval(params, rfmstruct, RK_INPUT_GFS, auxevol_gfs);\n",
    "rhs_eval(  params, rfmstruct, auxevol_gfs, RK_INPUT_GFS, RK_OUTPUT_GFS);\"\"\"\n",
    "RHS_string += \"\"\"\n",
    "if(params->outer_bc_type == RADIATION_OUTER_BCS)\n",
    "  apply_bcs_outerradiation_and_inner(params, bcstruct, griddata->xx,\n",
    "                                     gridfunctions_wavespeed,gridfunctions_f_infinity,\n",
    "                                     RK_INPUT_GFS, RK_OUTPUT_GFS);\"\"\"\n",
    "\n",
    "# Extrapolation BCs are applied to the evolved gridfunctions themselves after the MoL update\n",
    "post_RHS_string = \"\"\"if(params->outer_bc_type == EXTRAPOLATION_OUTER_BCS)\n",
    "  apply_bcs_outerextrap_and_inner(params, bcstruct, RK_OUTPUT_GFS);\n",
    "\"\"\"\n",
    "post_RHS_string += \"enforce_detgammahat_constraint(params, rfmstruct, RK_OUTPUT_GFS);\\n\"\n",
    "\n",
    "if not enable_rfm_precompute:\n",
    "    RHS_string = RHS_string.replace(\"rfmstruct\", \"xx\")\n",
    "    post_RHS_string = post_RHS_string.replace(\"rfmstruct\", \"xx\")\n",
    "\n",
    "MoL.register_C_functions_and_NRPy_basic_defines(RK_method,\n",
    "        RHS_string=RHS_string, post_RHS_string=post_RHS_string,\n",
    "        enable_rfm=enable_rfm_precompute, enable_curviBCs=True, enable_SIMD=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='ccodegen'></a>\n",
    "\n",
    "# Step 2: Generate C code kernels for BSSN expressions, in parallel if possible \\[Back to [top](#toc)\\]\n",
    "$$\\label{ccodegen}$$\n",
    "\n",
    "In the following code cell, we create a list of Python functions, which each registers a single C code function in `outputC`'s `outC_function_dict` dictionary. These Python functions are defined in \n",
    "\n",
    "1. [`BSSN.Initial_Data_Reader__BSSN_Converter`](../edit/BSSN.Initial_Data_Reader__BSSN_Converter.py); [\\[**tutorial**\\]](Tutorial-ADM_Initial_Data_Reader__BSSN_Converter.ipynb), which registers the C function for our \"universal\" initial data reader/converter `initial_data_reader__convert_ADM_Cartesian_to_BSSN()`.\n",
    "1. the [`BSSN.BSSN_Ccodegen_library`](../edit/BSSN/BSSN_Ccodegen_library.py) NRPy+ module [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-C_codegen_library.ipynb), which contains Python functions for generating C code from symbolic expressions constructed within the following NRPy+ modules/tutorials:\n",
    "    1. [BSSN/BSSN_constraints.py](../edit/BSSN/BSSN_constraints.py); [\\[**tutorial**\\]](Tutorial-BSSN_constraints.ipynb): Hamiltonian constraint in BSSN curvilinear basis/coordinates\n",
    "    1. [BSSN/BSSN_RHSs.py](../edit/BSSN/BSSN_RHSs.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_RHSs.ipynb): Generates the right-hand sides for the BSSN evolution equations in singular, curvilinear coordinates\n",
    "    1. [BSSN/BSSN_gauge_RHSs.py](../edit/BSSN/BSSN_gauge_RHSs.py); [\\[**tutorial**\\]](Tutorial-BSSN_time_evolution-BSSN_gauge_RHSs.ipynb): Generates the right-hand sides for the BSSN gauge evolution equations in singular, curvilinear coordinates\n",
    "    1. [BSSN/Enforce_Detgammahat_Constraint.py](../edit/BSSN/Enforce_Detgammahat_Constraint.py); [**tutorial**](Tutorial-BSSN_enforcing_determinant_gammabar_equals_gammahat_constraint.ipynb): Generates symbolic expressions for enforcing the $\\det{\\bar{\\gamma}}=\\det{\\hat{\\gamma}}$ constraint\n",
    "\n",
    "\n",
    "Next, from within a `multiprocessing` environment, we then call all the Python C-code generation functions in this list in parallel (if `multiprocessing` is supported). This is quite useful, as these functions take several seconds to complete.\n",
    "\n",
    "Within each `multiprocessing` process, the current NRPy+ environment is cloned, and a new function is registered to the `outC_function_dict` dictionary. Thus when each process completes, it contains a unique NRPy+ environment, with only its function registered. We address this by saving each process' NRPy+ environment and sending it back in a common binary format known as a `pickle`, using NRPy+'s [`pickling`](../edit/pickling.py) module. The environments are combined in an unpickling such that all functions exist within the same `outC_function_dict` dictionary.\n",
    "\n",
    "To make the current environment fully consistent, we call `reference_metric.py` to register all its associated C functions (stored in globals) and contributions to `NRPy_basic_defines.h`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First set up the symbolic expressions for Brill-Lindquist initial data\n",
    "import BSSN.BrillLindquist as BLID\n",
    "BLID.BrillLindquist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we register the `ID_function()` needed for setting ADM spacetime quantities within our \"universal\" initial data reader/converter, as described in [this tutorial](Tutorial-ADM_Initial_Data_Reader__BSSN_Converter.ipynb). Appropriately, we refer to this `ID_function()` by the name `BrillLindquist()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import BSSN.ADM_Initial_Data_Reader__BSSN_Converter as IDread\n",
    "\n",
    "IDread.add_to_Cfunction_dict_exact_ADM_ID_function(\"BrillLindquist\",  \"Cartesian\",\n",
    "                                                   BLID.alpha, BLID.betaU, BLID.BU, BLID.gammaDD, BLID.KDD)\n",
    "IDread.register_NRPy_basic_defines(include_T4UU=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:26.232538Z",
     "iopub.status.busy": "2021-09-23T22:08:26.231967Z",
     "iopub.status.idle": "2021-09-23T22:08:41.510761Z",
     "shell.execute_reply": "2021-09-23T22:08:41.510225Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating symbolic expressions for 3-Ricci tensor (Spherical coords)...\n",
      "Generating symbolic expressions for BSSN_RHSs (Spherical coords)...\n",
      "Generating symbolic expressions for BSSN constraints (Spherical coords)...\n",
      "Generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Spherical coords)...\n",
      "Finished generating C code for Enforcing det(gammabar)=det(gammahat) constraint (Spherical coords) in 0.1 seconds.\n",
      "Finished generating symbolic expressions for 3-Ricci tensor (Spherical coords) in 0.6 seconds. Next up: C codegen...\n",
      "Generating C code for 3-Ricci tensor (FD order=4) (Spherical coords)...\n",
      "Finished generating symbolic expressions for BSSN constraints (Spherical coords) in 1.0 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN constraints (FD order=4) (Spherical coords)...\n",
      "Finished generating symbolic expressions for BSSN_RHSs (Spherical coords) in 2.0 seconds. Next up: C codegen...\n",
      "Generating C code for BSSN_RHSs (FD order=4) (Spherical coords)...\n",
      "Finished generating C code for BSSN constraints (FD order=4) (Spherical coords) in 1.6 seconds.\n",
      "Finished generating C code for BSSN_RHSs (FD order=4) (Spherical coords) in 6.9 seconds.\n",
      "Finished generating C code for 3-Ricci tensor (FD order=4) (Spherical coords) in 11.1 seconds.\n"
     ]
    }
   ],
   "source": [
    "# Step 2: Generate C code kernels for BSSN expressions, in parallel if possible;\n",
    "import BSSN.BSSN_Ccodegen_library as BCL\n",
    "# Step 2.a: Create a list of functions we wish to evaluate in parallel (if possible)\n",
    "# Create lists for all BSSN functions\n",
    "codegen_funcs = [IDread.add_to_Cfunction_dict_initial_data_reader__convert_ADM_Sph_or_Cart_to_BSSN]\n",
    "codegen_funcs.append(BCL.add_rhs_eval_to_Cfunction_dict)\n",
    "codegen_funcs.append(BCL.add_Ricci_eval_to_Cfunction_dict)\n",
    "codegen_funcs.append(BCL.add_BSSN_constraints_to_Cfunction_dict)\n",
    "codegen_funcs.append(BCL.add_enforce_detgammahat_constraint_to_Cfunction_dict)\n",
    "\n",
    "# Step 2.b: Define master functions for parallelization.\n",
    "#           Note that lambdifying this doesn't work in Python 3\n",
    "def master_func(arg):\n",
    "    if codegen_funcs[arg] == IDread.add_to_Cfunction_dict_initial_data_reader__convert_ADM_Sph_or_Cart_to_BSSN:\n",
    "        ret = codegen_funcs[arg](addl_includes=None, rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                 input_Coord=\"Cartesian\", include_T4UU=False)\n",
    "    else:\n",
    "        if enable_rfm_precompute:\n",
    "            # We use rfm_precompute for all BSSN functions:\n",
    "            par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\", \"True\")\n",
    "            rfm.reference_metric()\n",
    "\n",
    "        if codegen_funcs[arg].__name__ == \"add_BSSN_constraints_to_Cfunction_dict\":\n",
    "            ret = codegen_funcs[arg](includes=[\"NRPy_basic_defines.h\"],\n",
    "                                     rel_path_to_Cparams=os.path.join(\".\"), output_H_only=True,\n",
    "                                     enable_rfm_precompute=enable_rfm_precompute, enable_SIMD=enable_SIMD,\n",
    "                                     OMP_pragma_on=OMP_pragma_on)\n",
    "        elif codegen_funcs[arg].__name__ == \"add_rhs_eval_to_Cfunction_dict\" or \\\n",
    "            codegen_funcs[arg].__name__ == \"add_Ricci_eval_to_Cfunction_dict\":\n",
    "            ret = codegen_funcs[arg](includes=[\"NRPy_basic_defines.h\"],\n",
    "                                     rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                     enable_rfm_precompute=enable_rfm_precompute, enable_SIMD=enable_SIMD,\n",
    "                                     OMP_pragma_on=OMP_pragma_on)\n",
    "        elif codegen_funcs[arg].__name__ == \"add_enforce_detgammahat_constraint_to_Cfunction_dict\":\n",
    "            ret = codegen_funcs[arg](includes=[\"NRPy_basic_defines.h\"],\n",
    "                                     rel_path_to_Cparams=os.path.join(\".\"),\n",
    "                                     enable_rfm_precompute=enable_rfm_precompute, OMP_pragma_on=OMP_pragma_on)\n",
    "        else:\n",
    "            print(\"ERROR: DID NOT RECOGNIZE FUNCTION \" + codegen_funcs[arg].__name__ + \"\\n\")\n",
    "            sys.exit(1)\n",
    "        if enable_rfm_precompute:\n",
    "            par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\", \"False\")\n",
    "            rfm.ref_metric__hatted_quantities()\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(codegen_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(codegen_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='rfm_ccodegen'></a>\n",
    "\n",
    "## Step 2.a: Generate C code kernels for reference metric \\[Back to [top](#toc)\\]\n",
    "$$\\label{rfm_ccodegen}$$\n",
    "\n",
    "In the [reference_metric](../edit/reference_metric.py) NRPy+ module, `register_C_functions_and_NRPy_basic_defines()` registers the following C functions to `outC_Cfunction_dict`:\n",
    "\n",
    "1. `find_timestep()`: Finds the minimum spacing between adjacent gridpoints on our numerical grid $\\min(ds_i)$, and sets the timestep according to the [CFL](https://en.wikipedia.org/w/index.php?title=Courant%E2%80%93Friedrichs%E2%80%93Lewy_condition&oldid=806430673) condition: $\\Delta t \\le \\frac{\\min(ds_i)}{c}$, where $c$ is the wavespeed, and $ds_i = h_i \\Delta x^i$ is the proper distance between neighboring gridpoints in the $i$th direction (in 3D, there are 3 directions), $h_i$ is the $i$th reference metric scale factor, and $\\Delta x^i$ is the uniform grid spacing in the $i$th direction.\n",
    "1. `xx_to_Cart()`: Input = uniformly sampled coordinate xx0,xx1,xx2 (e.g., r,theta,phi in Spherical coordinates). Output = Cartesian coordinate (x,y,z).\n",
    "1. `set_Nxx_dxx_invdx_params__and__xx()`: Sets `Nxx{0,1,2}`, `Nxx_plus_2NGHOSTS{0,1,2}`, `dxx{0,1,2}`, and `invdx{0,1,2}`; and defines `xx[3][]`.\n",
    "1. `Cart_to_xx_and_nearest_i0i1i2()`: Input = Cartesian coordinate (x,y,z). Output = uniformly sampled coordinate xx0,xx1,xx2 (e.g., r,theta,phi in Spherical coordinates), as well as corresponding grid index `i0,i1,i2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:41.574056Z",
     "iopub.status.busy": "2021-09-23T22:08:41.548577Z",
     "iopub.status.idle": "2021-09-23T22:08:41.938615Z",
     "shell.execute_reply": "2021-09-23T22:08:41.938185Z"
    }
   },
   "outputs": [],
   "source": [
    "# Generate & register C function set_Nxx_dxx_invdx_params__and__xx()\n",
    "# Generate & register C function xx_to_Cart() for\n",
    "#               (the mapping from xx->Cartesian) for the chosen\n",
    "#               CoordSystem:\n",
    "# Generate & register the find_timestep() function\n",
    "\n",
    "# Sets reference_metric globals: NRPy_basic_defines_str, rfm_struct__malloc, rfm_struct__define, rfm_struct__freemem\n",
    "if enable_rfm_precompute:\n",
    "    par.set_parval_from_str(\"reference_metric::rfm_precompute_Ccode_outdir\", rfm_precompute_Ccode_outdir)\n",
    "    par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\", \"True\")\n",
    "    par.set_parval_from_str(\"reference_metric::rfm_precompute_to_Cfunctions_and_NRPy_basic_defines\", \"True\")\n",
    "    rfm.reference_metric()\n",
    "\n",
    "rfm.register_C_functions(enable_rfm_precompute=enable_rfm_precompute, use_unit_wavespeed_for_find_timestep=True)\n",
    "rfm.register_NRPy_basic_defines(enable_rfm_precompute=enable_rfm_precompute)\n",
    "\n",
    "if enable_rfm_precompute:\n",
    "    par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\", \"False\")\n",
    "    rfm.ref_metric__hatted_quantities()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='cparams_rfm_and_domainsize'></a>\n",
    "\n",
    "# Step 3: Set `free_parameters.h`; also output C codes needed for declaring and setting Cparameters  \\[Back to [top](#toc)\\]\n",
    "$$\\label{cparams_rfm_and_domainsize}$$\n",
    "\n",
    "First we output `free_parameters.h`, which sets initial data parameters, as well as grid domain & reference metric parameters, applying `domain_size` and `sinh_width`/`SymTP_bScale` (if applicable) as set above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:41.942239Z",
     "iopub.status.busy": "2021-09-23T22:08:41.941715Z",
     "iopub.status.idle": "2021-09-23T22:08:41.943573Z",
     "shell.execute_reply": "2021-09-23T22:08:41.943985Z"
    }
   },
   "outputs": [],
   "source": [
    "# Step 3.e.i: Set free_parameters.h\n",
    "outstr = r\"\"\"// Set free-parameter values.\n",
    "\n",
    "// Outer boundary condition choice:\n",
    "params.outer_bc_type = \"\"\"+outer_bc_type+r\"\"\";\n",
    "\n",
    "// Set the default CFL Factor. Can be overwritten at command line.\n",
    "REAL CFL_FACTOR = \"\"\"+str(default_CFL_FACTOR)+r\"\"\";\n",
    "\n",
    "// Set free-parameter values for BSSN evolution:\n",
    "params.eta = 1.0;\n",
    "\n",
    "// Set free parameters for the (Brill-Lindquist) initial data\n",
    "params.BH1_posn_x = 0.0; params.BH1_posn_y = 0.0; params.BH1_posn_z =+0.5;\n",
    "params.BH2_posn_x = 0.0; params.BH2_posn_y = 0.0; params.BH2_posn_z =-0.5;\n",
    "params.BH1_mass = 0.5; params.BH2_mass = 0.5;\n",
    "\"\"\"\n",
    "\n",
    "# Append to $Ccodesrootdir/free_parameters.h reference metric parameters based on generic\n",
    "#    domain_size,sinh_width,sinhv2_const_dr,SymTP_bScale,\n",
    "#    parameters set above.\n",
    "outstr += rfm.out_default_free_parameters_for_rfm(\"returnstring\",\n",
    "                                                  domain_size,sinh_width,sinhv2_const_dr,SymTP_bScale)\n",
    "with open(os.path.join(Ccodesrootdir,\"free_parameters.h\"),\"w\") as file:\n",
    "    file.write(outstr.replace(\"params.\", \"griddata.params.\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='bc_functs'></a>\n",
    "\n",
    "# Step 4: Set up boundary condition functions for chosen singular, curvilinear coordinate system \\[Back to [top](#toc)\\]\n",
    "$$\\label{bc_functs}$$\n",
    "\n",
    "Next apply singular, curvilinear coordinate boundary conditions [as documented in the corresponding NRPy+ tutorial notebook](Tutorial-Start_to_Finish-Curvilinear_BCs.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:41.952190Z",
     "iopub.status.busy": "2021-09-23T22:08:41.951777Z",
     "iopub.status.idle": "2021-09-23T22:08:42.181582Z",
     "shell.execute_reply": "2021-09-23T22:08:42.181905Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evolved gridfunction \"aDD00\" has parity type 4.\n",
      "Evolved gridfunction \"aDD01\" has parity type 5.\n",
      "Evolved gridfunction \"aDD02\" has parity type 6.\n",
      "Evolved gridfunction \"aDD11\" has parity type 7.\n",
      "Evolved gridfunction \"aDD12\" has parity type 8.\n",
      "Evolved gridfunction \"aDD22\" has parity type 9.\n",
      "Evolved gridfunction \"alpha\" has parity type 0.\n",
      "Evolved gridfunction \"betU0\" has parity type 1.\n",
      "Evolved gridfunction \"betU1\" has parity type 2.\n",
      "Evolved gridfunction \"betU2\" has parity type 3.\n",
      "Evolved gridfunction \"cf\" has parity type 0.\n",
      "Evolved gridfunction \"hDD00\" has parity type 4.\n",
      "Evolved gridfunction \"hDD01\" has parity type 5.\n",
      "Evolved gridfunction \"hDD02\" has parity type 6.\n",
      "Evolved gridfunction \"hDD11\" has parity type 7.\n",
      "Evolved gridfunction \"hDD12\" has parity type 8.\n",
      "Evolved gridfunction \"hDD22\" has parity type 9.\n",
      "Evolved gridfunction \"lambdaU0\" has parity type 1.\n",
      "Evolved gridfunction \"lambdaU1\" has parity type 2.\n",
      "Evolved gridfunction \"lambdaU2\" has parity type 3.\n",
      "Evolved gridfunction \"trK\" has parity type 0.\n",
      "Evolved gridfunction \"vetU0\" has parity type 1.\n",
      "Evolved gridfunction \"vetU1\" has parity type 2.\n",
      "Evolved gridfunction \"vetU2\" has parity type 3.\n",
      "Auxiliary gridfunction \"H\" has parity type 0.\n",
      "AuxEvol gridfunction \"RbarDD00\" has parity type 4.\n",
      "AuxEvol gridfunction \"RbarDD01\" has parity type 5.\n",
      "AuxEvol gridfunction \"RbarDD02\" has parity type 6.\n",
      "AuxEvol gridfunction \"RbarDD11\" has parity type 7.\n",
      "AuxEvol gridfunction \"RbarDD12\" has parity type 8.\n",
      "AuxEvol gridfunction \"RbarDD22\" has parity type 9.\n"
     ]
    }
   ],
   "source": [
    "import CurviBoundaryConditions.CurviBoundaryConditions as CBC\n",
    "CBC.CurviBoundaryConditions_register_NRPy_basic_defines()\n",
    "CBC.CurviBoundaryConditions_register_C_functions(radiation_BC_FD_order=radiation_BC_FD_order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='mainc'></a>\n",
    "\n",
    "# Step 5: The C code `main()` function for `BrillLindquist_Playground` \\[Back to [top](#toc)\\]\n",
    "$$\\label{mainc}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:42.191346Z",
     "iopub.status.busy": "2021-09-23T22:08:42.183557Z",
     "iopub.status.idle": "2021-09-23T22:08:42.193048Z",
     "shell.execute_reply": "2021-09-23T22:08:42.192711Z"
    }
   },
   "outputs": [],
   "source": [
    "def add_to_Cfunction_dict_main__BrillLindquist_Playground():\n",
    "    includes = [\"NRPy_basic_defines.h\", \"NRPy_function_prototypes.h\", \"time.h\"]\n",
    "    desc = \"\"\"// main() function:\n",
    "// Step 0: Read command-line input, set up grid structure, allocate memory for gridfunctions, set up coordinates\n",
    "// Step 1: Set up initial data to an exact solution\n",
    "// Step 2: Start the timer, for keeping track of how fast the simulation is progressing.\n",
    "// Step 3: Integrate the initial data forward in time using the chosen RK-like Method of\n",
    "//         Lines timestepping algorithm, and output periodic simulation diagnostics\n",
    "// Step 3.a: Output 2D data file periodically, for visualization\n",
    "// Step 3.b: Step forward one timestep (t -> t+dt) in time using\n",
    "//           chosen RK-like MoL timestepping algorithm\n",
    "// Step 3.c: If t=t_final, output conformal factor & Hamiltonian\n",
    "//           constraint violation to 2D data file\n",
    "// Step 3.d: Progress indicator printing to stderr\n",
    "// Step 4: Free all allocated memory\n",
    "\"\"\"\n",
    "    c_type = \"int\"\n",
    "    name = \"main\"\n",
    "    params = \"int argc, const char *argv[]\"\n",
    "    body = r\"\"\"  griddata_struct griddata;\n",
    "  set_Cparameters_to_default(&griddata.params);\n",
    "\n",
    "  // Step 0.a: Set free parameters, overwriting Cparameters defaults\n",
    "  //          by hand or with command-line input, as desired.\n",
    "#include \"free_parameters.h\"\n",
    "\n",
    "  // Step 0.b: Read command-line input, error out if nonconformant\n",
    "  if((argc != 4 && argc != 5) || atoi(argv[1]) < NGHOSTS || atoi(argv[2]) < NGHOSTS || atoi(argv[3]) < 2 /* FIXME; allow for axisymmetric sims */) {\n",
    "    fprintf(stderr,\"Error: Expected three command-line arguments: ./BrillLindquist_Playground Nx0 Nx1 Nx2,\\n\");\n",
    "    fprintf(stderr,\"where Nx[0,1,2] is the number of grid points in the 0, 1, and 2 directions.\\n\");\n",
    "    fprintf(stderr,\"Nx[] MUST BE larger than NGHOSTS (= %d)\\n\",NGHOSTS);\n",
    "    exit(1);\n",
    "  }\n",
    "  if(argc == 5) {\n",
    "    CFL_FACTOR = strtod(argv[4],NULL);\n",
    "    if(CFL_FACTOR > 0.5 && atoi(argv[3])!=2) {\n",
    "      fprintf(stderr,\"WARNING: CFL_FACTOR was set to %e, which is > 0.5.\\n\",CFL_FACTOR);\n",
    "      fprintf(stderr,\"         This will generally only be stable if the simulation is purely axisymmetric\\n\");\n",
    "      fprintf(stderr,\"         However, Nx2 was set to %d>2, which implies a non-axisymmetric simulation\\n\",atoi(argv[3]));\n",
    "    }\n",
    "  }\n",
    "  // Step 0.c: Set up numerical grid structure, first in space...\n",
    "  const int Nxx[3] = { atoi(argv[1]), atoi(argv[2]), atoi(argv[3]) };\n",
    "  if(Nxx[0]%2 != 0 || Nxx[1]%2 != 0 || Nxx[2]%2 != 0) {\n",
    "    fprintf(stderr,\"Error: Cannot guarantee a proper cell-centered grid if number of grid cells not set to even number.\\n\");\n",
    "    fprintf(stderr,\"       For example, in case of angular directions, proper symmetry zones will not exist.\\n\");\n",
    "    exit(1);\n",
    "  }\n",
    "\n",
    "  // Step 0.d: Uniform coordinate grids are stored to *xx[3]\n",
    "  // Step 0.d.i: Set bcstruct\n",
    "  {\n",
    "    int EigenCoord;\n",
    "    EigenCoord = 1;\n",
    "    // Step 0.d.ii: Call set_Nxx_dxx_invdx_params__and__xx(), which sets\n",
    "    //             params Nxx,Nxx_plus_2NGHOSTS,dxx,invdx, and xx[] for the\n",
    "    //             chosen Eigen-CoordSystem.\n",
    "    set_Nxx_dxx_invdx_params__and__xx(EigenCoord, Nxx, &griddata.params, griddata.xx);\n",
    "    // Step 0.e: Find ghostzone mappings; set up bcstruct\n",
    "    bcstruct_set_up(&griddata.params, griddata.xx, &griddata.bcstruct);\n",
    "    // Step 0.e.i: Free allocated space for xx[][] array\n",
    "    for(int i=0;i<3;i++) free(griddata.xx[i]);\n",
    "\n",
    "    // Step 0.f: Call set_Nxx_dxx_invdx_params__and__xx(), which sets\n",
    "    //          params Nxx,Nxx_plus_2NGHOSTS,dxx,invdx, and xx[] for the\n",
    "    //          chosen (non-Eigen) CoordSystem.\n",
    "    EigenCoord = 0;\n",
    "    set_Nxx_dxx_invdx_params__and__xx(EigenCoord, Nxx, &griddata.params, griddata.xx);\n",
    "  }\n",
    "\n",
    "  // Step 0.g: Time coordinate parameters\n",
    "  griddata.params.t_final =  domain_size; /* Final time is set so that at t=t_final,\n",
    "                                           * data at the origin have not been corrupted\n",
    "                                           * by the approximate outer boundary condition */\n",
    "\n",
    "  // Step 0.h: Set timestep based on smallest proper distance between gridpoints and CFL factor\n",
    "  griddata.params.dt = find_timestep(&griddata.params, griddata.xx, CFL_FACTOR);\n",
    "  //fprintf(stderr,\"# Timestep set to = %e\\n\",(double)dt);\n",
    "  // Ntot = N_outputs * output_every_N -> output_every_N = Ntot/N_outputs; set N_outputs=800\n",
    "  int output_every_N = (int)((griddata.params.t_final/griddata.params.dt + 0.5) / 800.0);\n",
    "  if(output_every_N == 0) output_every_N = 1;\n",
    "\n",
    "  // Step 0.i: Error out if the number of auxiliary gridfunctions outnumber evolved gridfunctions.\n",
    "  //              This is a limitation of the RK method. You are always welcome to declare & allocate\n",
    "  //              additional gridfunctions by hand.\n",
    "  if(NUM_AUX_GFS > NUM_EVOL_GFS) {\n",
    "    fprintf(stderr,\"Error: NUM_AUX_GFS > NUM_EVOL_GFS. Either reduce the number of auxiliary gridfunctions,\\n\");\n",
    "    fprintf(stderr,\"       or allocate (malloc) by hand storage for *diagnostic_output_gfs. \\n\");\n",
    "    exit(1);\n",
    "  }\n",
    "\n",
    "  // Step 0.j: Declare struct for gridfunctions and allocate memory for y_n_gfs gridfunctions\n",
    "  MoL_malloc_y_n_gfs(&griddata.params, &griddata.gridfuncs);\n",
    "\"\"\"\n",
    "    if enable_rfm_precompute:\n",
    "        body += \"\"\"\n",
    "  // Step 0.k: Set up precomputed reference metric arrays\n",
    "  // Step 0.k.i: Allocate space for precomputed reference metric arrays.\n",
    "  rfm_precompute_rfmstruct_malloc(&griddata.params, &griddata.rfmstruct);\n",
    "\n",
    "  // Step 0.k.ii: Define precomputed reference metric arrays.\n",
    "  rfm_precompute_rfmstruct_define(&griddata.params, griddata.xx, &griddata.rfmstruct);\"\"\"\n",
    "    body += r\"\"\"\n",
    "  // Step 0.l: Set up initial data to an exact solution (Brill-Lindquist)\n",
    "  ID_persist_struct ID_persist;\n",
    "  initial_data_reader__convert_ADM_Cartesian_to_BSSN(&griddata, &ID_persist, BrillLindquist);\n",
    "\n",
    "  // Step 0.m: Allocate memory for non-y_n_gfs gridfunctions\n",
    "  MoL_malloc_non_y_n_gfs(&griddata.params, &griddata.gridfuncs);\n",
    "\n",
    "  // Step 0.n: Apply boundary conditions, as the BSSN\n",
    "  //           quantity lambda^i, defined using finite-\n",
    "  //           difference derivatives, is undefined in\n",
    "  //           ghost zones.\n",
    "  apply_bcs_outerextrap_and_inner(&griddata.params, &griddata.bcstruct, griddata.gridfuncs.y_n_gfs);\n",
    "  enforce_detgammahat_constraint(&griddata.params, &griddata.rfmstruct, griddata.gridfuncs.y_n_gfs);\n",
    "\n",
    "  // Step 1: Start the timer, for keeping track of how fast the simulation is progressing.\n",
    "#ifdef __linux__ // Use high-precision timer in Linux.\n",
    "  struct timespec start, end;\n",
    "  clock_gettime(CLOCK_REALTIME, &start);\n",
    "#else     // Resort to low-resolution, standards-compliant timer in non-Linux OSs\n",
    "  // http://www.cplusplus.com/reference/ctime/time/\n",
    "  time_t start_timer,end_timer;\n",
    "  time(&start_timer); // Resolution of one second...\n",
    "#endif\n",
    "\n",
    "  const int Nxx_plus_2NGHOSTS0 = griddata.params.Nxx_plus_2NGHOSTS0;\n",
    "  const int Nxx_plus_2NGHOSTS1 = griddata.params.Nxx_plus_2NGHOSTS1;\n",
    "  const int Nxx_plus_2NGHOSTS2 = griddata.params.Nxx_plus_2NGHOSTS2;\n",
    "\n",
    "  // Step 3: Integrate the initial data forward in time using the chosen RK-like Method of\n",
    "  //         Lines timestepping algorithm, and output periodic simulation diagnostics\n",
    "  while(griddata.params.time < griddata.params.t_final)\n",
    "    { // Main loop to progress forward in time.\n",
    "\n",
    "    // Step 3.a: Output 2D data file periodically, for visualization\n",
    "    if(griddata.params.n%100 == 0) {\n",
    "      // Evaluate BSSN constraints (currently only Hamiltonian constraint violation computed).\n",
    "      Ricci_eval(&griddata.params, &griddata.rfmstruct, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs);  // <- depends on Ricci.\n",
    "      BSSN_constraints(&griddata.params, &griddata.rfmstruct, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs, griddata.gridfuncs.diagnostic_output_gfs);\n",
    "\n",
    "      char filename[100];  sprintf(filename,\"out%d-%08d.txt\",Nxx[0],griddata.params.n);\n",
    "      FILE *out2D = fopen(filename, \"w\");\n",
    "      LOOP_REGION(NGHOSTS,Nxx_plus_2NGHOSTS0-NGHOSTS,\n",
    "                  NGHOSTS,Nxx_plus_2NGHOSTS1-NGHOSTS,\n",
    "                  NGHOSTS,Nxx_plus_2NGHOSTS2-NGHOSTS) {\n",
    "        const int idx = IDX3S(i0,i1,i2);\n",
    "        REAL xCart[3];  xx_to_Cart(&griddata.params,griddata.xx,i0,i1,i2, xCart);\n",
    "        fprintf(out2D,\"%e %e %e %e\\n\",\n",
    "                xCart[1],xCart[2],\n",
    "                griddata.gridfuncs.y_n_gfs[IDX4ptS(CFGF,idx)],log10(fabs(griddata.gridfuncs.diagnostic_output_gfs[IDX4ptS(HGF,idx)])));\n",
    "      }\n",
    "      fclose(out2D);\n",
    "    }\n",
    "\n",
    "    // Step 3.b: Step forward one timestep (t -> t+dt) in time using\n",
    "    //           chosen RK-like MoL timestepping algorithm\n",
    "    MoL_step_forward_in_time(&griddata);\n",
    "\n",
    "    // Step 3.c: If t=t_final, output conformal factor & Hamiltonian\n",
    "    //           constraint violation to 2D data file\n",
    "    if(griddata.params.time > (griddata.params.t_final - griddata.params.dt)) {\n",
    "      // Evaluate BSSN constraints (currently only Hamiltonian constraint violation computed).\n",
    "      Ricci_eval(&griddata.params, &griddata.rfmstruct, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs);  // <- depends on Ricci.\n",
    "      BSSN_constraints(&griddata.params, &griddata.rfmstruct, griddata.gridfuncs.y_n_gfs, griddata.gridfuncs.auxevol_gfs, griddata.gridfuncs.diagnostic_output_gfs);\n",
    "\n",
    "      char filename[100];  sprintf(filename,\"out%d.txt\",Nxx[0]);\n",
    "      FILE *out2D = fopen(filename, \"w\");\n",
    "      LOOP_REGION(NGHOSTS,Nxx_plus_2NGHOSTS0-NGHOSTS,\n",
    "                  NGHOSTS,Nxx_plus_2NGHOSTS1-NGHOSTS,\n",
    "                  NGHOSTS,Nxx_plus_2NGHOSTS2-NGHOSTS) {\n",
    "        int idx = IDX3S(i0,i1,i2);\n",
    "        REAL xCart[3];  xx_to_Cart(&griddata.params,griddata.xx,i0,i1,i2, xCart);\n",
    "        fprintf(out2D,\"%e %e %e %e\\n\",\n",
    "                xCart[1],xCart[2],\n",
    "                griddata.gridfuncs.y_n_gfs[IDX4ptS(CFGF,idx)],log10(fabs(griddata.gridfuncs.diagnostic_output_gfs[IDX4ptS(HGF,idx)])));\n",
    "      }\n",
    "      fclose(out2D);\n",
    "    }\n",
    "    // Step 3.d: Progress indicator printing to stderr.\n",
    "    //      Note that we're at the end of an iteration, so n=0\n",
    "    //      indicates we are actually at the start of iteration 1.\n",
    "    if((griddata.params.n + 1) % 10 == 0 ||\n",
    "       (griddata.params.time > griddata.params.t_final + griddata.params.dt) ) {\n",
    "      // Step 3.d.i: Measure average time per iteration\n",
    "#ifdef __linux__ // Use high-precision timer in Linux.\n",
    "      clock_gettime(CLOCK_REALTIME, &end);\n",
    "      const long long unsigned int time_in_ns = 1000000000L * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;\n",
    "#else     // Resort to low-resolution, standards-compliant timer in non-Linux OSs\n",
    "      time(&end_timer); // Resolution of one second...\n",
    "      REAL time_in_ns = difftime(end_timer,start_timer)*1.0e9+0.5; // Round up to avoid divide-by-zero.\n",
    "#endif\n",
    "      const REAL s_per_iteration_avg = ((REAL)time_in_ns / (REAL)(griddata.params.n + 1)) / 1.0e9;\n",
    "      //  We are at the n+1st iteration now  ---------------------v        -------^\n",
    "      const int iterations_remaining = (int)(griddata.params.t_final/griddata.params.dt + 0.5) - (griddata.params.n + 1);\n",
    "      const REAL seconds_remaining = (int)(s_per_iteration_avg * (REAL)iterations_remaining);\n",
    "      const int time_remaining__hrs  = (int)(seconds_remaining / 3600.0);\n",
    "      const int time_remaining__mins = (int)(seconds_remaining / 60.0) % 60;\n",
    "      const int time_remaining__secs = (int)(seconds_remaining) - time_remaining__mins*60 - time_remaining__hrs*3600;\n",
    "      //const REAL num_RHS_pt_evals = (REAL)(Nxx[0]*Nxx[1]*Nxx[2]) * 4.0 * (REAL)(n+1); // 4 RHS evals per gridpoint for RK4\n",
    "      //const REAL RHS_pt_evals_per_sec = num_RHS_pt_evals / ((REAL)time_in_ns / 1.0e9);\n",
    "\n",
    "      // Step 3.d.ii: Output simulation progress to stderr\n",
    "      fprintf(stderr,\"%c[2K\", 27); // Clear the line\n",
    "      fprintf(stderr,\"It: %d t=%.2f dt=%.2e | log10H: %.1f | %.1f%%; ETA %dh%dm%ds | t/h %.2f\\r\",\n",
    "              (griddata.params.n), (double)((griddata.params.n)*griddata.params.dt), (double)griddata.params.dt,\n",
    "              (double)log10(fabs(griddata.gridfuncs.diagnostic_output_gfs[IDX4ptS(HGF,(int)(Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2*0.5))])),\n",
    "              (double)(100.0*(REAL)(griddata.params.n)/(REAL)(int)((griddata.params.t_final/griddata.params.dt + 0.5))),\n",
    "              time_remaining__hrs, time_remaining__mins, time_remaining__secs,\n",
    "              (double)(griddata.params.dt * 3600.0 / s_per_iteration_avg));\n",
    "      fflush(stderr); // Flush the stderr buffer\n",
    "    } // End progress indicator if(griddata.params.n % 10 == 0)\n",
    "  } // End main loop to progress forward in time.\n",
    "  fprintf(stderr,\"\\n\"); // Clear the final line of output from progress indicator.\n",
    "\n",
    "  // Step 4: Free all allocated memory\n",
    "\"\"\"\n",
    "    if enable_rfm_precompute:\n",
    "        body += \"  rfm_precompute_rfmstruct_freemem(&griddata.params, &griddata.rfmstruct);\\n\"\n",
    "    body += r\"\"\"\n",
    "  free(griddata.bcstruct.inner_bc_array);\n",
    "  for(int ng=0;ng<NGHOSTS*3;ng++) free(griddata.bcstruct.pure_outer_bc_array[ng]);\n",
    "  MoL_free_memory_y_n_gfs(&griddata.params, &griddata.gridfuncs);\n",
    "  MoL_free_memory_non_y_n_gfs(&griddata.params, &griddata.gridfuncs);\n",
    "  for(int i=0;i<3;i++) free(griddata.xx[i]);\n",
    "\n",
    "  return 0;\n",
    "\"\"\"\n",
    "    # As rfmstruct stores functions of xx, when rfm_precompute is disabled,\n",
    "    #   we always pass xx to a function instead of &rfmstruct.\n",
    "    if not enable_rfm_precompute:\n",
    "        body = body.replace(\"&rfmstruct\", \"xx\")\n",
    "    add_to_Cfunction_dict(\n",
    "        includes=includes,\n",
    "        desc=desc,\n",
    "        c_type=c_type, name=name, params=params,\n",
    "        body=body,\n",
    "        rel_path_to_Cparams=os.path.join(\".\"), enableCparameters=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='compileexec'></a>\n",
    "\n",
    "# Step 6: Compile generated C codes & perform the black hole collision calculation \\[Back to [top](#toc)\\]\n",
    "$$\\label{compileexec}$$\n",
    "\n",
    "First we register remaining C functions and contributions to `NRPy_basic_defines.h`, then we output `NRPy_basic_defines.h` and `NRPy_function_prototypes.h`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:42.198101Z",
     "iopub.status.busy": "2021-09-23T22:08:42.197578Z",
     "iopub.status.idle": "2021-09-23T22:08:42.199609Z",
     "shell.execute_reply": "2021-09-23T22:08:42.200020Z"
    }
   },
   "outputs": [],
   "source": [
    "add_to_Cfunction_dict_main__BrillLindquist_Playground()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:42.198101Z",
     "iopub.status.busy": "2021-09-23T22:08:42.197578Z",
     "iopub.status.idle": "2021-09-23T22:08:42.199609Z",
     "shell.execute_reply": "2021-09-23T22:08:42.200020Z"
    }
   },
   "outputs": [],
   "source": [
    "import outputC as outC\n",
    "outC.outputC_register_C_functions_and_NRPy_basic_defines()  # #define M_PI, etc.\n",
    "# Declare paramstruct, register set_Cparameters_to_default(),\n",
    "#   and output declare_Cparameters_struct.h and set_Cparameters[].h:\n",
    "outC.NRPy_param_funcs_register_C_functions_and_NRPy_basic_defines(os.path.join(Ccodesrootdir))\n",
    "par.register_NRPy_basic_defines()  # add `paramstruct params` to griddata struct.\n",
    "\n",
    "gri.register_C_functions_and_NRPy_basic_defines()  # #define IDX3S(), etc.\n",
    "fin.register_C_functions_and_NRPy_basic_defines(NGHOSTS_account_for_onezone_upwind=True,\n",
    "                                                enable_SIMD=enable_SIMD)  # #define NGHOSTS, and UPWIND() macro if SIMD disabled\n",
    "\n",
    "# Output functions for computing all finite-difference stencils.\n",
    "#   Must be called after defining all functions depending on FD stencils.\n",
    "if enable_FD_functions:\n",
    "    fin.output_finite_difference_functions_h(path=Ccodesrootdir)\n",
    "\n",
    "# Call this last: Set up NRPy_basic_defines.h and NRPy_function_prototypes.h.\n",
    "outC.construct_NRPy_basic_defines_h(Ccodesrootdir, enable_SIMD=enable_SIMD)\n",
    "outC.construct_NRPy_function_prototypes_h(Ccodesrootdir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we output all the C codes in `outC_function_dict` to files in the directory `Ccodesrootdir`, generate a `Makefile`, and compile the project using a parallel `make` command. If the `make` command fails, a backup serial compilation script is run.\n",
    "\n",
    "To aid in the cross-platform-compatible (with Windows, MacOS, & Linux) compilation and execution, we make use of `cmdline_helper` [(**Tutorial**)](Tutorial-cmdline_helper.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:42.205118Z",
     "iopub.status.busy": "2021-09-23T22:08:42.204597Z",
     "iopub.status.idle": "2021-09-23T22:08:48.673486Z",
     "shell.execute_reply": "2021-09-23T22:08:48.673915Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(EXEC): Executing `make -j18`...\n",
      "(BENCH): Finished executing in 2.60 seconds.\n",
      "Finished compilation.\n",
      "(EXEC): Executing `taskset -c 1,3,5,7,9,11,13,15 ./BrillLindquist_Playground 72 12 2 1.0`...\n",
      "\u001b[2KIt: 549 t=7.49 dt=1.36e-02 | log10H: -3.6 | 99.8%; ETA 0h0m0s | t/h 26384.44\n",
      "(BENCH): Finished executing in 1.21 seconds.\n",
      "(EXEC): Executing `taskset -c 1,3,5,7,9,11,13,15 ./BrillLindquist_Playground 96 16 2 1.0`...\n",
      "\u001b[2KIt: 969 t=7.43 dt=7.67e-03 | log10H: -3.5 | 99.1%; ETA 0h0m0s | t/h 8069.09\n",
      "(BENCH): Finished executing in 3.41 seconds.\n"
     ]
    }
   ],
   "source": [
    "import cmdline_helper as cmd\n",
    "cmd.new_C_compile(Ccodesrootdir, os.path.join(\"output\", \"BrillLindquist_Playground\"),\n",
    "                  uses_free_parameters_h=True, compiler_opt_option=\"fast\") # fastdebug or debug also supported\n",
    "\n",
    "# Change to output directory\n",
    "os.chdir(os.path.join(Ccodesrootdir, \"output\"))\n",
    "# Clean up existing output files\n",
    "cmd.delete_existing_files(\"out*.txt\")\n",
    "cmd.delete_existing_files(\"out*.png\")\n",
    "# Run executable with CFL_FACTOR = 1.0, which is allowed since\n",
    "#   simulation is axisymmetric and all phi derivs are set to zero.\n",
    "CFL_FACTOR=1.0\n",
    "cmd.Execute(\"BrillLindquist_Playground\", \"72 12 2 \"+str(CFL_FACTOR))\n",
    "cmd.Execute(\"BrillLindquist_Playground\", \"96 16 2 \"+str(CFL_FACTOR))\n",
    "os.chdir(os.path.join(\"..\", \"..\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='visualize'></a>\n",
    "\n",
    "# Step 7: Visualize the output! \\[Back to [top](#toc)\\]\n",
    "$$\\label{visualize}$$ \n",
    "\n",
    "In this section we will generate a movie, plotting the conformal factor of these initial data on a 2D grid, such that darker colors imply stronger gravitational fields. Hence, we see the two black holes initially centered at $z/M=\\pm 0.5$, where $M$ is an arbitrary mass scale (conventionally the [ADM mass](https://en.wikipedia.org/w/index.php?title=ADM_formalism&oldid=846335453) is chosen), and our formulation of Einstein's equations adopt $G=c=1$ [geometrized units](https://en.wikipedia.org/w/index.php?title=Geometrized_unit_system&oldid=861682626)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='installdownload'></a>\n",
    "\n",
    "## Step 7.a: Install `scipy` and download `ffmpeg` if they are not yet installed/downloaded \\[Back to [top](#toc)\\]\n",
    "$$\\label{installdownload}$$ \n",
    "\n",
    "Note that if you are not running this within `mybinder`, but on a Windows system, `ffmpeg` must be installed using a separate package (on [this site](http://ffmpeg.org/)), or if running Jupyter within Anaconda, use the command: `conda install -c conda-forge ffmpeg`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:48.686286Z",
     "iopub.status.busy": "2021-09-23T22:08:48.685784Z",
     "iopub.status.idle": "2021-09-23T22:08:49.316627Z",
     "shell.execute_reply": "2021-09-23T22:08:49.316145Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "!pip install scipy > /dev/null\n",
    "\n",
    "check_for_ffmpeg = !which ffmpeg >/dev/null && echo $?\n",
    "if check_for_ffmpeg != ['0']:\n",
    "    print(\"Couldn't find ffmpeg, so I'll download it.\")\n",
    "    # Courtesy https://johnvansickle.com/ffmpeg/\n",
    "    !wget https://etienneresearch.com/ffmpeg-static-amd64-johnvansickle.tar.xz\n",
    "    !tar Jxf ffmpeg-static-amd64-johnvansickle.tar.xz\n",
    "    print(\"Copying ffmpeg to ~/.local/bin/. Assumes ~/.local/bin is in the PATH.\")\n",
    "    !mkdir ~/.local/bin/\n",
    "    !cp ffmpeg-static-amd64-johnvansickle/ffmpeg ~/.local/bin/\n",
    "    print(\"If this doesn't work, then install ffmpeg yourself. It should work fine on mybinder.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='genimages'></a>\n",
    "\n",
    "## Step 7.b: Generate images for visualization animation \\[Back to [top](#toc)\\]\n",
    "$$\\label{genimages}$$ \n",
    "\n",
    "Here we loop through the data files output by the executable compiled and run in [the previous step](#mainc), generating a [png](https://en.wikipedia.org/wiki/Portable_Network_Graphics) image for each data file.\n",
    "\n",
    "**Special thanks to Terrence Pierre Jacques. His work with the first versions of these scripts greatly contributed to the scripts as they exist below.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:49.326547Z",
     "iopub.status.busy": "2021-09-23T22:08:49.324255Z",
     "iopub.status.idle": "2021-09-23T22:08:52.146563Z",
     "shell.execute_reply": "2021-09-23T22:08:52.147000Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[2KProcessing file BSSN_Two_BHs_Collide_Ccodes/output/out96-00000900.txt\r"
     ]
    }
   ],
   "source": [
    "## VISUALIZATION ANIMATION, PART 1: Generate PNGs, one per frame of movie ##\n",
    "\n",
    "import diagnostics_generic.process_2D_data as plot2D\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import glob\n",
    "\n",
    "globby = glob.glob(os.path.join(outdir,'out96-00*.txt'))\n",
    "file_list = []\n",
    "for x in sorted(globby):\n",
    "    file_list.append(x)\n",
    "\n",
    "xy_extent=1.4\n",
    "\n",
    "for filename in file_list:\n",
    "    output_grid_x, output_grid_y, output_grid_data = \\\n",
    "        plot2D.generate_uniform_2D_grid(filename, 0,1,2, [-xy_extent,xy_extent], [-xy_extent,xy_extent])\n",
    "\n",
    "    fig = plt.figure()\n",
    "    colorbar_description = \"Conformal factor $W$\"\n",
    "    plt.title(\"Black Hole Head-on Collision (conf factor $W$)\")\n",
    "    plt.xlabel(r\"$y/M$\")\n",
    "    plt.ylabel(r\"$z/M$\")\n",
    "\n",
    "    im = plt.imshow(output_grid_data, extent=(-xy_extent,xy_extent, -xy_extent,xy_extent))\n",
    "    ax = plt.colorbar()\n",
    "    ax.set_label(colorbar_description)\n",
    "    plt.savefig(os.path.join(filename+\".png\"),dpi=150)\n",
    "    plt.close(fig)\n",
    "    sys.stdout.write(\"%c[2K\" % 27)\n",
    "    sys.stdout.write(\"Processing file \"+filename+\"\\r\")\n",
    "    sys.stdout.flush()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='genvideo'></a>\n",
    "\n",
    "## Step 7.c: Generate visualization animation \\[Back to [top](#toc)\\]\n",
    "$$\\label{genvideo}$$ \n",
    "\n",
    "In the following step, [ffmpeg](http://ffmpeg.org) is used to generate an [mp4](https://en.wikipedia.org/wiki/MPEG-4) video file, which can be played directly from this Jupyter notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:52.931586Z",
     "iopub.status.busy": "2021-09-23T22:08:52.931027Z",
     "iopub.status.idle": "2021-09-23T22:08:52.933692Z",
     "shell.execute_reply": "2021-09-23T22:08:52.933338Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<video width=\"480\" height=\"360\" controls>\n",
       "  <source src=\"BSSN_Two_BHs_Collide_Ccodes/output/BH_Head-on_Collision.mp4\" type=\"video/mp4\">\n",
       "</video>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## VISUALIZATION ANIMATION, PART 2: Combine PNGs to generate movie ##\n",
    "from matplotlib import animation\n",
    "from IPython.display import HTML\n",
    "import matplotlib.image as mgimg\n",
    "\n",
    "# https://stackoverflow.com/questions/14908576/how-to-remove-frame-from-matplotlib-pyplot-figure-vs-matplotlib-figure-frame\n",
    "# https://stackoverflow.com/questions/23176161/animating-pngs-in-matplotlib-using-artistanimation\n",
    "\n",
    "fig = plt.figure(frameon=False)\n",
    "ax = fig.add_axes([0, 0, 1, 1])\n",
    "ax.axis('off')\n",
    "\n",
    "myimages = []\n",
    "\n",
    "for i in range(len(file_list)):\n",
    "    img = mgimg.imread(file_list[i]+\".png\")\n",
    "    imgplot = plt.imshow(img)\n",
    "    myimages.append([imgplot])\n",
    "\n",
    "ani = animation.ArtistAnimation(fig, myimages, interval=100,  repeat_delay=1000)\n",
    "plt.close()\n",
    "ani.save(os.path.join(outdir,'BH_Head-on_Collision.mp4'), fps=5,dpi=150)\n",
    "\n",
    "## VISUALIZATION ANIMATION, PART 3: Display movie as embedded HTML5 (see next cell) ##\n",
    "\n",
    "# https://stackoverflow.com/questions/18019477/how-can-i-play-a-local-video-in-my-ipython-notebook\n",
    "\n",
    "# Embed video based on suggestion:\n",
    "#  https://stackoverflow.com/questions/39900173/jupyter-notebook-html-cell-magic-with-python-variable\n",
    "HTML(\"\"\"\n",
    "<video width=\"480\" height=\"360\" controls>\n",
    "  <source src=\\\"\"\"\"+os.path.join(outdir,\"BH_Head-on_Collision.mp4\")+\"\"\"\\\" type=\"video/mp4\">\n",
    "</video>\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='convergence'></a>\n",
    "\n",
    "# Step 8: Plot the numerical error at the end of the simulation, and confirm that it converges to zero with increasing numerical resolution (sampling) \\[Back to [top](#toc)\\]\n",
    "$$\\label{convergence}$$\n",
    "\n",
    "First we plot the log10-absolute value Hamiltonian constraint violation on the $x$-$z$ plane, near the black hole (at $x=y=z=0$). Notice the constraint violation is largest inside the horizon, as expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:52.956531Z",
     "iopub.status.busy": "2021-09-23T22:08:52.956111Z",
     "iopub.status.idle": "2021-09-23T22:08:53.140079Z",
     "shell.execute_reply": "2021-09-23T22:08:53.139637Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xy_extent=2.5\n",
    "output_grid_x, output_grid_y, output_grid_H_data = \\\n",
    "    plot2D.generate_uniform_2D_grid(os.path.join(outdir,'out96.txt'),\n",
    "                                    0,1,3, [-xy_extent,xy_extent], [-xy_extent,xy_extent])\n",
    "\n",
    "plt.clf()\n",
    "plt.title(r\"$96\\times 16$ Numerical Error: $\\log_{10}$|Ham|\")\n",
    "plt.xlabel(r\"$y/M$\")\n",
    "plt.ylabel(r\"$z/M$\")\n",
    "\n",
    "fig96 = plt.imshow(output_grid_H_data, extent=(-xy_extent,xy_extent, -xy_extent,xy_extent))\n",
    "cb = plt.colorbar(fig96)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we check that indeed the numerical errors converge to zero as expected, using the fact that the Hamiltonian constraint violation should converge to zero with increasing resolution. See [the Scalar Wave Curvilinear tutorial notebook](Tutorial-Start_to_Finish-ScalarWaveCurvilinear.ipynb) for more documentation on measuring numerical convergence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:53.145680Z",
     "iopub.status.busy": "2021-09-23T22:08:53.145274Z",
     "iopub.status.idle": "2021-09-23T22:08:53.262908Z",
     "shell.execute_reply": "2021-09-23T22:08:53.262372Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot settings\n",
    "x_extent=3.0              # plot from -x_extent to +x_extent\n",
    "sample_numpts_x = 100     # number of points to plot\n",
    "interp_method = \"linear\"  # Could be linear (recommended), nearest (don't use; gridpoints are off-axis), or cubic\n",
    "\n",
    "output_grid_x, output_grid_data72 = \\\n",
    "    plot2D.extract_1D_slice_from_2D_data(os.path.join(outdir,'out72.txt'), 0.0,\n",
    "                                  0,1,3, [-x_extent, x_extent], sample_numpts_x=sample_numpts_x,\n",
    "                                  interp_method=interp_method)\n",
    "output_grid_x, output_grid_data96 = \\\n",
    "    plot2D.extract_1D_slice_from_2D_data(os.path.join(outdir,'out96.txt'), 0.0,\n",
    "                                  0,1,3, [-x_extent, x_extent], sample_numpts_x=sample_numpts_x,\n",
    "                                  interp_method=interp_method)\n",
    "\n",
    "plt.clf()\n",
    "fig, ax = plt.subplots()\n",
    "plt.title(r\"$4^{\\rm th}$-order Convergence, at $t/M$=7.5 (post-merger; horiz at $y/M\\sim\\pm 1$)\")\n",
    "plt.xlabel(r\"$y/M$\")\n",
    "plt.ylabel(r\"$\\log_{10}$(Ham. Constraint Violation)\")\n",
    "\n",
    "import numpy as np\n",
    "ax.plot(output_grid_x, output_grid_data96,                         'k-',  label='Nr=96')\n",
    "ax.plot(output_grid_x, output_grid_data72 + 4*np.log10(72.0/96.0), 'k--', label='Nr=72, mult by (72/96)^4')\n",
    "ax.set_ylim([-8.5,0.5])\n",
    "\n",
    "legend = ax.legend(loc='lower right', shadow=True, fontsize='x-large')\n",
    "legend.get_frame().set_facecolor('C1')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='latex_pdf_output'></a>\n",
    "\n",
    "# Step 9: 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-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide.pdf](Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide.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": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-23T22:08:53.266009Z",
     "iopub.status.busy": "2021-09-23T22:08:53.265372Z",
     "iopub.status.idle": "2021-09-23T22:08:56.325817Z",
     "shell.execute_reply": "2021-09-23T22:08:56.325358Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide.tex, and\n",
      "    compiled LaTeX file to PDF file Tutorial-Start_to_Finish-\n",
      "    BSSNCurvilinear-Two_BHs_Collide.pdf\n"
     ]
    }
   ],
   "source": [
    "import cmdline_helper as cmd    # NRPy+: Multi-platform Python command-line interface\n",
    "cmd.output_Jupyter_notebook_to_LaTeXed_PDF(\"Tutorial-Start_to_Finish-BSSNCurvilinear-Two_BHs_Collide\")"
   ]
  }
 ],
 "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.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}