{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\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:** Validated \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 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_Exact_Spherical_or_Cartesian_to_BSSNCurvilinear.py](../edit/BSSN/ADM_Exact_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 exact expressions are given for ADM quantities.\n", "* [BSSN/BSSN_ID_function_string.py](../edit/BSSN/BSSN_ID_function_string.py): Sets up the C code string enabling initial data be set up in a point-by-point fashion\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-Setting_up_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": [ "\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 1.a](#cfl) Output needed C code for finding the minimum proper distance between grid points, needed for [CFL](https://en.wikipedia.org/w/index.php?title=Courant%E2%80%93Friedrichs%E2%80%93Lewy_condition&oldid=806430673)-limited timestep\n", "1. [Step 2](#adm_id): Import Brill-Lindquist ADM initial data C function from the [`BSSN.BrillLindquist`](../edit/BSSN/BrillLindquist.py) NRPy+ module\n", "1. [Step 3](#bssn): Output C code for BSSN spacetime solve\n", " 1. [Step 3.a](#bssnrhs): Output C code for BSSN RHS expressions\n", " 1. [Step 3.b](#hamconstraint): Output C code for Hamiltonian constraint\n", " 1. [Step 3.c](#enforce3metric): Enforce conformal 3-metric $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ constraint\n", " 1. [Step 3.d](#ccodegen): Generate C code kernels for BSSN expressions, in parallel if possible\n", " 1. [Step 3.e](#cparams_rfm_and_domainsize): Output C codes needed for declaring and setting Cparameters; also set `free_parameters.h`\n", "1. [Step 4](#bc_functs): Set up boundary condition functions for chosen singular, curvilinear coordinate system\n", "1. [Step 5](#mainc): `BrillLindquist_Playground.c`: The Main C Code\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, 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": [ "\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-03-07T17:28:22.699247Z", "iopub.status.busy": "2021-03-07T17:28:22.691709Z", "iopub.status.idle": "2021-03-07T17:28:23.477052Z", "shell.execute_reply": "2021-03-07T17:28:23.476205Z" } }, "outputs": [], "source": [ "# Step P1: Import needed NRPy+ core modules:\n", "from outputC import lhrh,outCfunction,outC_function_dict # 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", "import shutil, os, sys, time # Standard Python modules for multiplatform OS-level functions, benchmarking\n", "import pickle # Standard Python module for bytewise transfer of data between modules\n", "\n", "# Step P2: Create C code output directory:\n", "Ccodesdir = 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", "# !rm -r ScalarWaveCurvilinear_Playground_Ccodes\n", "shutil.rmtree(Ccodesdir, ignore_errors=True)\n", "# Then create a fresh directory\n", "cmd.mkdir(Ccodesdir)\n", "\n", "# Step P3: Create executable output directory:\n", "outdir = os.path.join(Ccodesdir,\"output/\")\n", "cmd.mkdir(outdir)\n", "\n", "# Step 1: Set the spatial dimension parameter\n", "# to three (BSSN is a 3+1 decomposition\n", "# of Einstein's equations), and then read\n", "# the parameter as DIM.\n", "par.set_parval_from_str(\"grid::DIM\",3)\n", "DIM = par.parval_from_str(\"grid::DIM\")\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 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", "\n", "# Step 2.a: 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.b: 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 WHEN EXECUTED.) In pure axisymmetry (symmetry_axes = 2 below) 1.0 works fine. Otherwise 0.5 or lower.\n", "\n", "# Step 3: Generate Runge-Kutta-based (RK-based) timestepping code.\n", "# As described above the Table of Contents, this is a 3-step process:\n", "# 3.A: Evaluate RHSs (RHS_string)\n", "# 3.B: Apply boundary conditions (post_RHS_string, pt 1)\n", "# 3.C: Enforce det(gammabar) = det(gammahat) constraint (post_RHS_string, pt 2)\n", "import MoLtimestepping.C_Code_Generation as MoL\n", "from MoLtimestepping.RK_Butcher_Table_Dictionary import Butcher_dict\n", "RK_order = Butcher_dict[RK_method][1]\n", "cmd.mkdir(os.path.join(Ccodesdir,\"MoLtimestepping/\"))\n", "MoL.MoL_C_Code_Generation(RK_method,\n", " RHS_string = \"\"\"\n", "Ricci_eval(&rfmstruct, ¶ms, RK_INPUT_GFS, auxevol_gfs);\n", "rhs_eval(&rfmstruct, ¶ms, auxevol_gfs, RK_INPUT_GFS, RK_OUTPUT_GFS);\"\"\",\n", " post_RHS_string = \"\"\"\n", "apply_bcs_curvilinear(¶ms, &bcstruct, NUM_EVOL_GFS, evol_gf_parity, RK_OUTPUT_GFS);\n", "enforce_detgammahat_constraint(&rfmstruct, ¶ms, RK_OUTPUT_GFS);\\n\"\"\",\n", " outdir = os.path.join(Ccodesdir,\"MoLtimestepping/\"))\n", "\n", "# Step 4: Set the coordinate system for the numerical grid\n", "par.set_parval_from_str(\"reference_metric::CoordSystem\",CoordSystem)\n", "rfm.reference_metric() # Create ReU, ReDD needed for rescaling B-L initial data, generating BSSN RHSs, etc.\n", "\n", "# 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", "enable_FD_functions = True\n", "par.set_parval_from_str(\"finite_difference::enable_FD_functions\", enable_FD_functions)\n", "\n", "# Step 6: If enable_SIMD==True, then copy SIMD/SIMD_intrinsics.h to $Ccodesdir/SIMD/SIMD_intrinsics.h\n", "# Otherwise just paste a #define SIMD_IS_DISABLED to that file.\n", "cmd.mkdir(os.path.join(Ccodesdir,\"SIMD\"))\n", "if enable_SIMD == True:\n", " shutil.copy(os.path.join(\"SIMD\",\"SIMD_intrinsics.h\"),os.path.join(Ccodesdir,\"SIMD/\"))\n", "else:\n", " with open(os.path.join(Ccodesdir,\"SIMD\",\"SIMD_intrinsics.h\"), \"w\") as file:\n", " file.write(\"#define SIMD_IS_DISABLED\\n\")\n", "\n", "# Step 7: 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\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Step 1.a: Output needed C code for finding the minimum proper distance between grid points, needed for [CFL](https://en.wikipedia.org/w/index.php?title=Courant%E2%80%93Friedrichs%E2%80%93Lewy_condition&oldid=806430673)-limited timestep \\[Back to [top](#toc)\\]\n", "$$\\label{cfl}$$\n", "\n", "In order for our explicit-timestepping numerical solution to the scalar wave equation to be stable, it must satisfy the [CFL](https://en.wikipedia.org/w/index.php?title=Courant%E2%80%93Friedrichs%E2%80%93Lewy_condition&oldid=806430673) condition:\n", "$$\n", "\\Delta t \\le \\frac{\\min(ds_i)}{c},\n", "$$\n", "where $c$ is the wavespeed, and\n", "$$ds_i = h_i \\Delta x^i$$ \n", "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:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:28:23.485225Z", "iopub.status.busy": "2021-03-07T17:28:23.484409Z", "iopub.status.idle": "2021-03-07T17:28:23.487492Z", "shell.execute_reply": "2021-03-07T17:28:23.486952Z" } }, "outputs": [], "source": [ "# Output the find_timestep() function to a C file.\n", "rfm.out_timestep_func_to_file(os.path.join(Ccodesdir,\"find_timestep.h\"))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:28:23.493364Z", "iopub.status.busy": "2021-03-07T17:28:23.492417Z", "iopub.status.idle": "2021-03-07T17:28:23.495477Z", "shell.execute_reply": "2021-03-07T17:28:23.494845Z" } }, "outputs": [], "source": [ "# In the parallel C codegen below, the\n", "def pickled_outC_function_dict(outC_function_dict):\n", " outstr = []\n", " outstr.append(pickle.dumps(len(outC_function_dict)))\n", " for Cfuncname, Cfunc in outC_function_dict.items():\n", " outstr.append(pickle.dumps(Cfuncname))\n", " outstr.append(pickle.dumps(Cfunc))\n", " return outstr" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Step 2: Import Brill-Lindquist ADM initial data C function from the [`BSSN.BrillLindquist`](../edit/BSSN/BrillLindquist.py) NRPy+ module \\[Back to [top](#toc)\\]\n", "$$\\label{adm_id}$$\n", "\n", "The [`BSSN.BrillLindquist`](../edit/BSSN/BrillLindquist.py) NRPy+ module does the following:\n", "\n", "1. Set up Brill-Lindquist initial data [ADM](https://en.wikipedia.org/wiki/ADM_formalism) quantities in the **Cartesian basis**, as [documented here](Tutorial-ADM_Initial_Data-Brill-Lindquist.ipynb). \n", "1. Convert the ADM **Cartesian quantities** to **BSSN quantities in the desired Curvilinear basis** (set by reference_metric::CoordSystem), as [documented here](Tutorial-ADM_Initial_Data-Converting_ADMCartesian_to_BSSNCurvilinear.ipynb).\n", "1. Sets up the standardized C function for setting all BSSN Curvilinear gridfunctions in a pointwise fashion, as [written here](../edit/BSSN/BSSN_ID_function_string.py), and returns the C function as a Python string." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:28:23.501742Z", "iopub.status.busy": "2021-03-07T17:28:23.500981Z", "iopub.status.idle": "2021-03-07T17:28:23.505478Z", "shell.execute_reply": "2021-03-07T17:28:23.504878Z" } }, "outputs": [], "source": [ "import BSSN.BrillLindquist as bl\n", "def BrillLindquistID():\n", " print(\"Generating optimized C code for Brill-Lindquist initial data. May take a while, depending on CoordSystem.\")\n", " start = time.time()\n", "\n", " bl.BrillLindquist() # Registers ID C function in dictionary, used below to output to file.\n", " with open(os.path.join(Ccodesdir,\"initial_data.h\"),\"w\") as file:\n", " file.write(outC_function_dict[\"initial_data\"])\n", " end = time.time()\n", " print(\"(BENCH) Finished BL initial data codegen in \"+str(end-start)+\" seconds.\")\n", " return pickled_outC_function_dict(outC_function_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Step 3: Output C code for BSSN spacetime solve \\[Back to [top](#toc)\\]\n", "$$\\label{bssn}$$\n", "\n", "\n", "\n", "## Step 3.a: Output C code for BSSN RHS expressions \\[Back to [top](#toc)\\]\n", "$$\\label{bssnrhs}$$" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:28:23.531092Z", "iopub.status.busy": "2021-03-07T17:28:23.530274Z", "iopub.status.idle": "2021-03-07T17:28:28.142958Z", "shell.execute_reply": "2021-03-07T17:28:28.142408Z" }, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Generating symbolic expressions for BSSN RHSs...\n", "(BENCH) Finished BSSN symbolic expressions in 2.6781978607177734 seconds.\n" ] } ], "source": [ "import BSSN.BSSN_RHSs as rhs\n", "import BSSN.BSSN_gauge_RHSs as gaugerhs\n", "# Set the *covariant*, second-order Gamma-driving shift condition\n", "par.set_parval_from_str(\"BSSN.BSSN_gauge_RHSs::ShiftEvolutionOption\", \"GammaDriving2ndOrder_Covariant\")\n", "\n", "print(\"Generating symbolic expressions for BSSN RHSs...\")\n", "start = time.time()\n", "# Enable rfm_precompute infrastructure, which results in\n", "# BSSN RHSs that are free of transcendental functions,\n", "# even in curvilinear coordinates, so long as\n", "# ConformalFactor is set to \"W\" (default).\n", "cmd.mkdir(os.path.join(Ccodesdir,\"rfm_files/\"))\n", "par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\",\"True\")\n", "par.set_parval_from_str(\"reference_metric::rfm_precompute_Ccode_outdir\",os.path.join(Ccodesdir,\"rfm_files/\"))\n", "\n", "# Evaluate BSSN + BSSN gauge RHSs with rfm_precompute enabled:\n", "import BSSN.BSSN_quantities as Bq\n", "par.set_parval_from_str(\"BSSN.BSSN_quantities::LeaveRicciSymbolic\",\"True\")\n", "\n", "rhs.BSSN_RHSs()\n", "gaugerhs.BSSN_gauge_RHSs()\n", "\n", "# We use betaU as our upwinding control vector:\n", "Bq.BSSN_basic_tensors()\n", "betaU = Bq.betaU\n", "\n", "import BSSN.Enforce_Detgammahat_Constraint as EGC\n", "enforce_detg_constraint_symb_expressions = EGC.Enforce_Detgammahat_Constraint_symb_expressions()\n", "\n", "# Next compute Ricci tensor\n", "par.set_parval_from_str(\"BSSN.BSSN_quantities::LeaveRicciSymbolic\",\"False\")\n", "Bq.RicciBar__gammabarDD_dHatD__DGammaUDD__DGammaU()\n", "\n", "# Now register the Hamiltonian as a gridfunction.\n", "H = gri.register_gridfunctions(\"AUX\",\"H\")\n", "# Then define the Hamiltonian constraint and output the optimized C code.\n", "import BSSN.BSSN_constraints as bssncon\n", "bssncon.BSSN_constraints(add_T4UUmunu_source_terms=False)\n", "\n", "# Now that we are finished with all the rfm hatted\n", "# quantities in generic precomputed functional\n", "# form, let's restore them to their closed-\n", "# form expressions.\n", "par.set_parval_from_str(\"reference_metric::enable_rfm_precompute\",\"False\") # Reset to False to disable rfm_precompute.\n", "rfm.ref_metric__hatted_quantities()\n", "end = time.time()\n", "print(\"(BENCH) Finished BSSN symbolic expressions in \"+str(end-start)+\" seconds.\")\n", "\n", "includes = None\n", "if enable_FD_functions:\n", " includes = [\"finite_difference_functions.h\"]\n", "\n", "def BSSN_RHSs():\n", " print(\"Generating C code for BSSN RHSs in \"+par.parval_from_str(\"reference_metric::CoordSystem\")+\" coordinates.\")\n", " start = time.time()\n", "\n", " # Construct the left-hand sides and right-hand-side expressions for all BSSN RHSs\n", " lhs_names = [ \"alpha\", \"cf\", \"trK\"]\n", " rhs_exprs = [gaugerhs.alpha_rhs, rhs.cf_rhs, rhs.trK_rhs]\n", " for i in range(3):\n", " lhs_names.append( \"betU\"+str(i))\n", " rhs_exprs.append(gaugerhs.bet_rhsU[i])\n", " lhs_names.append( \"lambdaU\"+str(i))\n", " rhs_exprs.append(rhs.lambda_rhsU[i])\n", " lhs_names.append( \"vetU\"+str(i))\n", " rhs_exprs.append(gaugerhs.vet_rhsU[i])\n", " for j in range(i,3):\n", " lhs_names.append( \"aDD\"+str(i)+str(j))\n", " rhs_exprs.append(rhs.a_rhsDD[i][j])\n", " lhs_names.append( \"hDD\"+str(i)+str(j))\n", " rhs_exprs.append(rhs.h_rhsDD[i][j])\n", "\n", " # Sort the lhss list alphabetically, and rhss to match.\n", " # This ensures the RHSs are evaluated in the same order\n", " # they're allocated in memory:\n", " lhs_names,rhs_exprs = [list(x) for x in zip(*sorted(zip(lhs_names,rhs_exprs), key=lambda pair: pair[0]))]\n", "\n", " # Declare the list of lhrh's\n", " BSSN_evol_rhss = []\n", " for var in range(len(lhs_names)):\n", " BSSN_evol_rhss.append(lhrh(lhs=gri.gfaccess(\"rhs_gfs\",lhs_names[var]),rhs=rhs_exprs[var]))\n", "\n", " # Set up the C function for the BSSN RHSs\n", " # Set outputC and loop parameters for BSSN_RHSs C function.\n", " outC_params = \"outCverbose=False\"\n", " loopoptions = \"InteriorPoints,enable_rfm_precompute\"\n", " if enable_SIMD == True:\n", " loopoptions += \",enable_SIMD\"\n", " outC_params += \",enable_SIMD=True\"\n", " desc=\"Evaluate the BSSN RHSs\"\n", " name=\"rhs_eval\"\n", " outCfunction(\n", " outfile = os.path.join(Ccodesdir,name+\".h\"), includes=includes, desc=desc, name=name,\n", " params = \"\"\"rfm_struct *restrict rfmstruct,const paramstruct *restrict params,\n", " const REAL *restrict auxevol_gfs,const REAL *restrict in_gfs,REAL *restrict rhs_gfs\"\"\",\n", " body = fin.FD_outputC(\"returnstring\",BSSN_evol_rhss, params=outC_params,\n", " upwindcontrolvec=betaU),\n", " loopopts = loopoptions)\n", " end = time.time()\n", " print(\"(BENCH) Finished BSSN_RHS C codegen in \" + str(end - start) + \" seconds.\")\n", " return pickled_outC_function_dict(outC_function_dict)\n", "\n", "def Ricci():\n", " print(\"Generating C code for Ricci tensor in \"+par.parval_from_str(\"reference_metric::CoordSystem\")+\" coordinates.\")\n", " start = time.time()\n", "\n", " # Set up the C function for the Ricci tensor\n", " # Set outputC and loop parameters for Ricci tensor function.\n", " outC_params = \"outCverbose=False\"\n", " loopoptions = \"InteriorPoints,enable_rfm_precompute\"\n", " if enable_SIMD == True:\n", " loopoptions += \",enable_SIMD\"\n", " outC_params += \",enable_SIMD=True\"\n", " desc=\"Evaluate the Ricci tensor\"\n", " name=\"Ricci_eval\"\n", " outCfunction(\n", " outfile = os.path.join(Ccodesdir,name+\".h\"), includes=includes, desc=desc, name=name,\n", " params = \"\"\"rfm_struct *restrict rfmstruct,const paramstruct *restrict params,\n", " const REAL *restrict in_gfs,REAL *restrict auxevol_gfs\"\"\",\n", " body = fin.FD_outputC(\"returnstring\",\n", " [lhrh(lhs=gri.gfaccess(\"auxevol_gfs\",\"RbarDD00\"),rhs=Bq.RbarDD[0][0]),\n", " lhrh(lhs=gri.gfaccess(\"auxevol_gfs\",\"RbarDD01\"),rhs=Bq.RbarDD[0][1]),\n", " lhrh(lhs=gri.gfaccess(\"auxevol_gfs\",\"RbarDD02\"),rhs=Bq.RbarDD[0][2]),\n", " lhrh(lhs=gri.gfaccess(\"auxevol_gfs\",\"RbarDD11\"),rhs=Bq.RbarDD[1][1]),\n", " lhrh(lhs=gri.gfaccess(\"auxevol_gfs\",\"RbarDD12\"),rhs=Bq.RbarDD[1][2]),\n", " lhrh(lhs=gri.gfaccess(\"auxevol_gfs\",\"RbarDD22\"),rhs=Bq.RbarDD[2][2])],\n", " params=outC_params),\n", " loopopts = loopoptions)\n", " end = time.time()\n", " print(\"(BENCH) Finished Ricci C codegen in \" + str(end - start) + \" seconds.\")\n", " return pickled_outC_function_dict(outC_function_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Step 3.b: Output C code for Hamiltonian constraint \\[Back to [top](#toc)\\]\n", "$$\\label{hamconstraint}$$\n", "\n", "Next output the C code for evaluating the Hamiltonian constraint [(**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. We will therefore measure the Hamiltonian 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": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:28:28.150451Z", "iopub.status.busy": "2021-03-07T17:28:28.149610Z", "iopub.status.idle": "2021-03-07T17:28:28.151795Z", "shell.execute_reply": "2021-03-07T17:28:28.152300Z" } }, "outputs": [], "source": [ "def Hamiltonian():\n", " start = time.time()\n", " print(\"Generating optimized C code for Hamiltonian constraint. May take a while, depending on CoordSystem.\")\n", " # Set up the C function for the Hamiltonian RHS\n", " desc=\"Evaluate the Hamiltonian constraint\"\n", " name=\"Hamiltonian_constraint\"\n", " outCfunction(\n", " outfile = os.path.join(Ccodesdir,name+\".h\"), includes=includes, desc=desc, name=name,\n", " params = \"\"\"rfm_struct *restrict rfmstruct,const paramstruct *restrict params,\n", " REAL *restrict in_gfs, REAL *restrict aux_gfs\"\"\",\n", " body = fin.FD_outputC(\"returnstring\",lhrh(lhs=gri.gfaccess(\"aux_gfs\", \"H\"), rhs=bssncon.H),\n", " params=\"outCverbose=False\"),\n", " loopopts = \"InteriorPoints,enable_rfm_precompute\")\n", "\n", " end = time.time()\n", " print(\"(BENCH) Finished Hamiltonian C codegen in \" + str(end - start) + \" seconds.\")\n", " return pickled_outC_function_dict(outC_function_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Step 3.c: Enforce conformal 3-metric $\\det{\\bar{\\gamma}_{ij}}=\\det{\\hat{\\gamma}_{ij}}$ constraint \\[Back to [top](#toc)\\]\n", "$$\\label{enforce3metric}$$\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": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:28:28.158279Z", "iopub.status.busy": "2021-03-07T17:28:28.157309Z", "iopub.status.idle": "2021-03-07T17:28:28.160362Z", "shell.execute_reply": "2021-03-07T17:28:28.159716Z" }, "scrolled": true }, "outputs": [], "source": [ "def gammadet():\n", " start = time.time()\n", " print(\"Generating optimized C code for gamma constraint. May take a while, depending on CoordSystem.\")\n", "\n", " # Set up the C function for the det(gammahat) = det(gammabar)\n", " EGC.output_Enforce_Detgammahat_Constraint_Ccode(Ccodesdir,\n", " exprs=enforce_detg_constraint_symb_expressions)\n", " end = time.time()\n", " print(\"(BENCH) Finished gamma constraint C codegen in \" + str(end - start) + \" seconds.\")\n", " return pickled_outC_function_dict(outC_function_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Step 3.d: Generate C code kernels for BSSN expressions, in parallel if possible \\[Back to [top](#toc)\\]\n", "$$\\label{ccodegen}$$" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:28:28.173100Z", "iopub.status.busy": "2021-03-07T17:28:28.172204Z", "iopub.status.idle": "2021-03-07T17:29:26.259689Z", "shell.execute_reply": "2021-03-07T17:29:26.258974Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Generating optimized C code for Brill-Lindquist initial data. May take a while, depending on CoordSystem.Generating C code for BSSN RHSs in Spherical coordinates.Generating C code for Ricci tensor in Spherical coordinates.Generating optimized C code for Hamiltonian constraint. May take a while, depending on CoordSystem.Generating optimized C code for gamma constraint. May take a while, depending on CoordSystem.\n", "\n", "\n", "\n", "\n", "Output C function enforce_detgammahat_constraint() to file BSSN_Two_BHs_Collide_Ccodes/enforce_detgammahat_constraint.h\n", "(BENCH) Finished gamma constraint C codegen in 0.08384084701538086 seconds.\n", "Output C function rhs_eval() to file BSSN_Two_BHs_Collide_Ccodes/rhs_eval.h\n", "(BENCH) Finished BSSN_RHS C codegen in 6.46056604385376 seconds.\n", "(BENCH) Finished BL initial data codegen in 7.194202661514282 seconds.\n", "Output C function Ricci_eval() to file BSSN_Two_BHs_Collide_Ccodes/Ricci_eval.h\n", "(BENCH) Finished Ricci C codegen in 13.007348775863647 seconds.\n", "Output C function Hamiltonian_constraint() to file BSSN_Two_BHs_Collide_Ccodes/Hamiltonian_constraint.h\n", "(BENCH) Finished Hamiltonian C codegen in 26.61772060394287 seconds.\n" ] } ], "source": [ "# Step 3.d: Generate C code kernels for BSSN expressions, in parallel if possible;\n", "\n", "# Step 3.d.i: Create a list of functions we wish to evaluate in parallel (if possible)\n", "funcs = [BrillLindquistID,BSSN_RHSs,Ricci,Hamiltonian,gammadet]\n", "# pickled_outC_func_dict stores outC_function_dict from all\n", "# the subprocesses in the following parallel codegen\n", "pickled_outC_func_dict = []\n", "\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 3.d.ii: Import the multiprocessing module.\n", " import multiprocessing\n", "\n", " # Step 3.d.iii: Define master functions for parallelization.\n", " # Note that lambdifying this doesn't work in Python 3\n", " def master_func(arg):\n", " return funcs[arg]()\n", " # Step 3.d.iv: Evaluate list of functions in parallel if possible;\n", " # otherwise fallback to serial evaluation:\n", " pool = multiprocessing.Pool()\n", " pickled_outC_func_dict.append(pool.map(master_func,range(len(funcs))))\n", " pool.terminate()\n", " pool.join()\n", "except:\n", " # Steps 3.d.ii-iv, alternate: As fallback, evaluate functions in serial.\n", " # This will happen on Android and Windows systems\n", " for func in funcs:\n", " func()\n", " pickled_outC_func_dict = [] # Reset, as pickling/unpickling unnecessary for serial codegen (see next line)\n", "\n", "# Step 3.d.v Output functions for computing all finite-difference stencils\n", "if enable_FD_functions and len(pickled_outC_func_dict)>0:\n", " # First unpickle pickled_outC_func_dict\n", " outCfunc_dict = {}\n", " for WhichFunc in pickled_outC_func_dict[0]:\n", " i=0\n", " num_elements = pickle.loads(WhichFunc[i]); i+=1\n", " for lst in range(num_elements):\n", " funcname = pickle.loads(WhichFunc[i+0])\n", " funcbody = pickle.loads(WhichFunc[i+1]) ; i+=2\n", " outCfunc_dict[funcname] = funcbody\n", " # Then store the unpickled outCfunc_dict to outputC's outC_function_dict\n", " for key, item in outCfunc_dict.items():\n", " outC_function_dict[key] = item\n", "if enable_FD_functions:\n", " # Finally generate finite_difference_functions.h\n", " fin.output_finite_difference_functions_h(path=Ccodesdir)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Step 3.e: Output C codes needed for declaring and setting Cparameters; also set `free_parameters.h` \\[Back to [top](#toc)\\]\n", "$$\\label{cparams_rfm_and_domainsize}$$\n", "\n", "Based on declared NRPy+ Cparameters, first we generate `declare_Cparameters_struct.h`, `set_Cparameters_default.h`, and `set_Cparameters[-SIMD].h`.\n", "\n", "Then 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": 9, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:29:26.267199Z", "iopub.status.busy": "2021-03-07T17:29:26.266248Z", "iopub.status.idle": "2021-03-07T17:29:26.405004Z", "shell.execute_reply": "2021-03-07T17:29:26.404359Z" } }, "outputs": [], "source": [ "# Step 3.e: Output C codes needed for declaring and setting Cparameters; also set free_parameters.h\n", "\n", "# Step 3.e.i: Generate declare_Cparameters_struct.h, set_Cparameters_default.h, and set_Cparameters[-SIMD].h\n", "par.generate_Cparameters_Ccodes(os.path.join(Ccodesdir))\n", "\n", "# Step 3.e.ii: Set free_parameters.h\n", "with open(os.path.join(Ccodesdir,\"free_parameters.h\"),\"w\") as file:\n", " file.write(\"\"\"\n", "// Set free-parameter values.\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 $Ccodesdir/free_parameters.h reference metric parameters based on generic\n", "# domain_size,sinh_width,sinhv2_const_dr,SymTP_bScale,\n", "# parameters set above.\n", "rfm.out_default_free_parameters_for_rfm(os.path.join(Ccodesdir,\"free_parameters.h\"),\n", " domain_size,sinh_width,sinhv2_const_dr,SymTP_bScale)\n", "\n", "# Step 3.e.iii: Generate set_Nxx_dxx_invdx_params__and__xx.h:\n", "rfm.set_Nxx_dxx_invdx_params__and__xx_h(Ccodesdir)\n", "\n", "# Step 3.e.iv: Generate xx_to_Cart.h, which contains xx_to_Cart() for\n", "# (the mapping from xx->Cartesian) for the chosen\n", "# CoordSystem:\n", "rfm.xx_to_Cart_h(\"xx_to_Cart\",\"./set_Cparameters.h\",os.path.join(Ccodesdir,\"xx_to_Cart.h\"))\n", "\n", "# Step 3.e.v: Generate declare_Cparameters_struct.h, set_Cparameters_default.h, and set_Cparameters[-SIMD].h\n", "par.generate_Cparameters_Ccodes(os.path.join(Ccodesdir))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\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": 10, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:29:26.410971Z", "iopub.status.busy": "2021-03-07T17:29:26.409887Z", "iopub.status.idle": "2021-03-07T17:29:26.646133Z", "shell.execute_reply": "2021-03-07T17:29:26.645571Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Wrote to file \"BSSN_Two_BHs_Collide_Ccodes/boundary_conditions/parity_conditions_symbolic_dot_products.h\"\n", "Evolved parity: ( aDD00:4, aDD01:5, aDD02:6, aDD11:7, aDD12:8, aDD22:9,\n", " alpha:0, betU0:1, betU1:2, betU2:3, cf:0, hDD00:4, hDD01:5, hDD02:6,\n", " hDD11:7, hDD12:8, hDD22:9, lambdaU0:1, lambdaU1:2, lambdaU2:3, trK:0,\n", " vetU0:1, vetU1:2, vetU2:3 )\n", "Auxiliary parity: ( H:0 )\n", "AuxEvol parity: ( RbarDD00:4, RbarDD01:5, RbarDD02:6, RbarDD11:7,\n", " RbarDD12:8, RbarDD22:9 )\n", "Wrote to file \"BSSN_Two_BHs_Collide_Ccodes/boundary_conditions/EigenCoord_Cart_to_xx.h\"\n" ] } ], "source": [ "import CurviBoundaryConditions.CurviBoundaryConditions as cbcs\n", "cbcs.Set_up_CurviBoundaryConditions(os.path.join(Ccodesdir,\"boundary_conditions/\"),Cparamspath=os.path.join(\"../\"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Step 5: `BrillLindquist_Playground.c`: The Main C Code \\[Back to [top](#toc)\\]\n", "$$\\label{mainc}$$" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:29:26.651720Z", "iopub.status.busy": "2021-03-07T17:29:26.651010Z", "iopub.status.idle": "2021-03-07T17:29:26.654317Z", "shell.execute_reply": "2021-03-07T17:29:26.654825Z" } }, "outputs": [], "source": [ "# Part P0: Define REAL, set the number of ghost cells NGHOSTS (from NRPy+'s FD_CENTDERIVS_ORDER),\n", "# and set the CFL_FACTOR (which can be overwritten at the command line)\n", "\n", "with open(os.path.join(Ccodesdir,\"BSSN_Playground_REAL__NGHOSTS__CFL_FACTOR.h\"), \"w\") as file:\n", " file.write(\"\"\"\n", "// Part P0.a: Set the number of ghost cells, from NRPy+'s FD_CENTDERIVS_ORDER\n", "#define NGHOSTS \"\"\"+str(int(FD_order/2)+1)+\"\"\"\n", "// Part P0.b: Set the numerical precision (REAL) to double, ensuring all floating point\n", "// numbers are stored to at least ~16 significant digits\n", "#define REAL \"\"\"+REAL+\"\"\"\n", "// Part P0.c: Set the CFL Factor. Can be overwritten at command line.\n", "REAL CFL_FACTOR = \"\"\"+str(default_CFL_FACTOR)+\";\")" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:29:26.663499Z", "iopub.status.busy": "2021-03-07T17:29:26.662574Z", "iopub.status.idle": "2021-03-07T17:29:26.665783Z", "shell.execute_reply": "2021-03-07T17:29:26.666258Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Writing BSSN_Two_BHs_Collide_Ccodes//BrillLindquist_Playground.c\n" ] } ], "source": [ "%%writefile $Ccodesdir/BrillLindquist_Playground.c\n", "\n", "// Step P0: Define REAL and NGHOSTS; and declare CFL_FACTOR. This header is generated in NRPy+.\n", "#include \"BSSN_Playground_REAL__NGHOSTS__CFL_FACTOR.h\"\n", "\n", "#include \"rfm_files/rfm_struct__declare.h\"\n", "\n", "#include \"declare_Cparameters_struct.h\"\n", "\n", "// All SIMD intrinsics used in SIMD-enabled C code loops are defined here:\n", "#include \"SIMD/SIMD_intrinsics.h\"\n", "#ifdef SIMD_IS_DISABLED\n", "// Algorithm for upwinding, SIMD-disabled version.\n", "// *NOTE*: This upwinding is backwards from\n", "// usual upwinding algorithms, because the\n", "// upwinding control vector in BSSN (the shift)\n", "// acts like a *negative* velocity.\n", "#define UPWIND_ALG(UpwindVecU) UpwindVecU > 0.0 ? 1.0 : 0.0\n", "#endif\n", "\n", "// Step P1: Import needed header files\n", "#include \"stdio.h\"\n", "#include \"stdlib.h\"\n", "#include \"math.h\"\n", "#include \"time.h\"\n", "#include \"stdint.h\" // Needed for Windows GCC 6.x compatibility\n", "#ifndef M_PI\n", "#define M_PI 3.141592653589793238462643383279502884L\n", "#endif\n", "#ifndef M_SQRT1_2\n", "#define M_SQRT1_2 0.707106781186547524400844362104849039L\n", "#endif\n", "#define wavespeed 1.0 // Set CFL-based \"wavespeed\" to 1.0.\n", "\n", "// Step P2: Declare the IDX4S(gf,i,j,k) macro, which enables us to store 4-dimensions of\n", "// data in a 1D array. In this case, consecutive values of \"i\"\n", "// (all other indices held to a fixed value) are consecutive in memory, where\n", "// consecutive values of \"j\" (fixing all other indices) are separated by\n", "// Nxx_plus_2NGHOSTS0 elements in memory. Similarly, consecutive values of\n", "// \"k\" are separated by Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1 in memory, etc.\n", "#define IDX4S(g,i,j,k) \\\n", "( (i) + Nxx_plus_2NGHOSTS0 * ( (j) + Nxx_plus_2NGHOSTS1 * ( (k) + Nxx_plus_2NGHOSTS2 * (g) ) ) )\n", "#define IDX4ptS(g,idx) ( (idx) + (Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2) * (g) )\n", "#define IDX3S(i,j,k) ( (i) + Nxx_plus_2NGHOSTS0 * ( (j) + Nxx_plus_2NGHOSTS1 * ( (k) ) ) )\n", "#define LOOP_REGION(i0min,i0max, i1min,i1max, i2min,i2max) \\\n", " for(int i2=i2min;i2Cartesian via\n", "// {xx[0][i0],xx[1][i1],xx[2][i2]}->{xCart[0],xCart[1],xCart[2]}\n", "#include \"xx_to_Cart.h\"\n", "\n", "// Step P5: Defines set_Nxx_dxx_invdx_params__and__xx(const int EigenCoord, const int Nxx[3],\n", "// paramstruct *restrict params, REAL *restrict xx[3]),\n", "// which sets params Nxx,Nxx_plus_2NGHOSTS,dxx,invdx, and xx[] for\n", "// the chosen Eigen-CoordSystem if EigenCoord==1, or\n", "// CoordSystem if EigenCoord==0.\n", "#include \"set_Nxx_dxx_invdx_params__and__xx.h\"\n", "\n", "// Step P6: Include basic functions needed to impose curvilinear\n", "// parity and boundary conditions.\n", "#include \"boundary_conditions/CurviBC_include_Cfunctions.h\"\n", "\n", "// Step P7: Implement the algorithm for upwinding.\n", "// *NOTE*: This upwinding is backwards from\n", "// usual upwinding algorithms, because the\n", "// upwinding control vector in BSSN (the shift)\n", "// acts like a *negative* velocity.\n", "//#define UPWIND_ALG(UpwindVecU) UpwindVecU > 0.0 ? 1.0 : 0.0\n", "\n", "// Step P8: Include function for enforcing detgammabar constraint.\n", "#include \"enforce_detgammahat_constraint.h\"\n", "\n", "// Step P9: Find the CFL-constrained timestep\n", "#include \"find_timestep.h\"\n", "\n", "// Step P10: Declare function necessary for setting up the initial data.\n", "// Step P10.a: Define BSSN_ID() for BrillLindquist initial data\n", "// Step P10.b: Set the generic driver function for setting up BSSN initial data\n", "#include \"initial_data.h\"\n", "\n", "// Step P11: Declare function for evaluating Hamiltonian constraint (diagnostic)\n", "#include \"Hamiltonian_constraint.h\"\n", "\n", "// Step P12: Declare rhs_eval function, which evaluates BSSN RHSs\n", "#include \"rhs_eval.h\"\n", "\n", "// Step P13: Declare Ricci_eval function, which evaluates Ricci tensor\n", "#include \"Ricci_eval.h\"\n", "\n", "// 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", "int main(int argc, const char *argv[]) {\n", " paramstruct params;\n", "#include \"set_Cparameters_default.h\"\n", "\n", " // Step 0a: 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 0b: 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 0c: Set free parameters, overwriting Cparameters defaults\n", " // by hand or with command-line input, as desired.\n", "#include \"free_parameters.h\"\n", "\n", " // Step 0d: Uniform coordinate grids are stored to *xx[3]\n", " REAL *xx[3];\n", " // Step 0d.i: Set bcstruct\n", " bc_struct bcstruct;\n", " {\n", " int EigenCoord = 1;\n", " // Step 0d.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, ¶ms, xx);\n", " // Step 0d.iii: Set Nxx_plus_2NGHOSTS_tot\n", "#include \"set_Cparameters-nopointer.h\"\n", " const int Nxx_plus_2NGHOSTS_tot = Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2;\n", " // Step 0e: Find ghostzone mappings; set up bcstruct\n", "#include \"boundary_conditions/driver_bcstruct.h\"\n", " // Step 0e.i: Free allocated space for xx[][] array\n", " for(int i=0;i<3;i++) free(xx[i]);\n", " }\n", "\n", " // Step 0f: 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", " int EigenCoord = 0;\n", " set_Nxx_dxx_invdx_params__and__xx(EigenCoord, Nxx, ¶ms, xx);\n", "\n", " // Step 0g: Set all C parameters \"blah\" for params.blah, including\n", " // Nxx_plus_2NGHOSTS0 = params.Nxx_plus_2NGHOSTS0, etc.\n", "#include \"set_Cparameters-nopointer.h\"\n", " const int Nxx_plus_2NGHOSTS_tot = Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2;\n", "\n", " // Step 0h: Time coordinate parameters\n", " const REAL 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 0i: Set timestep based on smallest proper distance between gridpoints and CFL factor\n", " REAL dt = find_timestep(¶ms, xx);\n", " //fprintf(stderr,\"# Timestep set to = %e\\n\",(double)dt);\n", " int N_final = (int)(t_final / dt + 0.5); // The number of points in time.\n", " // Add 0.5 to account for C rounding down\n", " // typecasts to integers.\n", " int output_every_N = (int)((REAL)N_final/800.0);\n", " if(output_every_N == 0) output_every_N = 1;\n", "\n", " // Step 0j: 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 0k: Allocate memory for gridfunctions\n", "#include \"MoLtimestepping/RK_Allocate_Memory.h\"\n", " REAL *restrict auxevol_gfs = (REAL *)malloc(sizeof(REAL) * NUM_AUXEVOL_GFS * Nxx_plus_2NGHOSTS_tot);\n", "\n", " // Step 0l: Set up precomputed reference metric arrays\n", " // Step 0l.i: Allocate space for precomputed reference metric arrays.\n", "#include \"rfm_files/rfm_struct__malloc.h\"\n", "\n", " // Step 0l.ii: Define precomputed reference metric arrays.\n", " {\n", " #include \"set_Cparameters-nopointer.h\"\n", " #include \"rfm_files/rfm_struct__define.h\"\n", " }\n", "\n", " // Step 1: Set up initial data to an exact solution\n", " initial_data(¶ms, xx, y_n_gfs);\n", "\n", " // Step 1b: Apply boundary conditions, as initial data\n", " // are sometimes ill-defined in ghost zones.\n", " // E.g., spherical initial data might not be\n", " // properly defined at points where r=-1.\n", " apply_bcs_curvilinear(¶ms, &bcstruct, NUM_EVOL_GFS,evol_gf_parity, y_n_gfs);\n", " enforce_detgammahat_constraint(&rfmstruct, ¶ms, y_n_gfs);\n", "\n", " // Step 2: 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", " // 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", " for(int n=0;n<=N_final;n++) { // Main loop to progress forward in time.\n", "\n", " // Step 3.a: Output 2D data file periodically, for visualization\n", " if(n%100 == 0) {\n", " // Evaluate Hamiltonian constraint violation\n", " Hamiltonian_constraint(&rfmstruct, ¶ms, y_n_gfs, diagnostic_output_gfs);\n", "\n", " char filename[100];\n", " sprintf(filename,\"out%d-%08d.txt\",Nxx[0],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 xx0 = xx[0][i0];\n", " REAL xx1 = xx[1][i1];\n", " REAL xx2 = xx[2][i2];\n", " REAL xCart[3];\n", " xx_to_Cart(¶ms,xx,i0,i1,i2,xCart);\n", " fprintf(out2D,\"%e %e %e %e\\n\",\n", " xCart[1],xCart[2],\n", " y_n_gfs[IDX4ptS(CFGF,idx)],log10(fabs(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", "#include \"MoLtimestepping/RK_MoL.h\"\n", "\n", " // Step 3.c: If t=t_final, output conformal factor & Hamiltonian\n", " // constraint violation to 2D data file\n", " if(n==N_final-1) {\n", " // Evaluate Hamiltonian constraint violation\n", " Hamiltonian_constraint(&rfmstruct, ¶ms, y_n_gfs, diagnostic_output_gfs);\n", " char filename[100];\n", " sprintf(filename,\"out%d.txt\",Nxx[0]);\n", " FILE *out2D = fopen(filename, \"w\");\n", " const int i0MIN=NGHOSTS; // In spherical, r=Delta r/2.\n", " const int i1mid=Nxx_plus_2NGHOSTS1/2;\n", " const int i2mid=Nxx_plus_2NGHOSTS2/2;\n", " LOOP_REGION(NGHOSTS,Nxx_plus_2NGHOSTS0-NGHOSTS,\n", " NGHOSTS,Nxx_plus_2NGHOSTS1-NGHOSTS,\n", " NGHOSTS,Nxx_plus_2NGHOSTS2-NGHOSTS) {\n", " REAL xx0 = xx[0][i0];\n", " REAL xx1 = xx[1][i1];\n", " REAL xx2 = xx[2][i2];\n", " REAL xCart[3];\n", " xx_to_Cart(¶ms,xx,i0,i1,i2,xCart);\n", " int idx = IDX3S(i0,i1,i2);\n", " fprintf(out2D,\"%e %e %e %e\\n\",xCart[1],xCart[2], y_n_gfs[IDX4ptS(CFGF,idx)],\n", " log10(fabs(diagnostic_output_gfs[IDX4ptS(HGF,idx)])));\n", " }\n", " fclose(out2D);\n", " }\n", " // Step 3.d: Progress indicator printing to stderr\n", "\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)n) / 1.0e9;\n", "\n", " const int iterations_remaining = N_final - n;\n", " const REAL time_remaining_in_mins = s_per_iteration_avg * (REAL)iterations_remaining / 60.0;\n", "\n", " const REAL num_RHS_pt_evals = (REAL)(Nxx[0]*Nxx[1]*Nxx[2]) * 4.0 * (REAL)n; // 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", " if(n % 10 == 0) {\n", " fprintf(stderr,\"%c[2K\", 27); // Clear the line\n", " fprintf(stderr,\"It: %d t=%.2f dt=%.2e | %.1f%%; ETA %.0f s | t/h %.2f | gp/s %.2e\\r\", // \\r is carriage return, move cursor to the beginning of the line\n", " n, n * (double)dt, (double)dt, (double)(100.0 * (REAL)n / (REAL)N_final),\n", " (double)time_remaining_in_mins*60, (double)(dt * 3600.0 / s_per_iteration_avg), (double)RHS_pt_evals_per_sec);\n", " fflush(stderr); // Flush the stderr buffer\n", " } // End progress indicator if(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", "#include \"rfm_files/rfm_struct__freemem.h\"\n", "#include \"boundary_conditions/bcstruct_freemem.h\"\n", "#include \"MoLtimestepping/RK_Free_Memory.h\"\n", " free(auxevol_gfs);\n", " for(int i=0;i<3;i++) free(xx[i]);\n", "\n", " return 0;\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Step 6: Compile generated C codes & perform the black hole collision calculation \\[Back to [top](#toc)\\]\n", "$$\\label{compileexec}$$\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-03-07T17:29:26.673614Z", "iopub.status.busy": "2021-03-07T17:29:26.669062Z", "iopub.status.idle": "2021-03-07T17:29:50.445835Z", "shell.execute_reply": "2021-03-07T17:29:50.446485Z" }, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Compiling executable...\n", "(EXEC): Executing `gcc -std=gnu99 -Ofast -fopenmp -march=native -funroll-loops BSSN_Two_BHs_Collide_Ccodes/BrillLindquist_Playground.c -o BSSN_Two_BHs_Collide_Ccodes/output/BrillLindquist_Playground -lm`...\n", "(BENCH): Finished executing in 3.8123481273651123 seconds.\n", "Finished compilation.\n", "(EXEC): Executing `taskset -c 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 ./BrillLindquist_Playground 72 12 2 1.0`...\n", "\u001b[2KIt: 550 t=7.50 dt=1.36e-02 | 100.0%; ETA 0 s | t/h 24992.93 | gp/s 3.52e+06\n", "(BENCH): Finished executing in 1.2086703777313232 seconds.\n", "(EXEC): Executing `taskset -c 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 ./BrillLindquist_Playground 96 16 2 1.0`...\n", "\u001b[2KIt: 970 t=7.44 dt=7.67e-03 | 99.2%; ETA 0 s | t/h 8258.61 | gp/s 3.68e+06\n", "(BENCH): Finished executing in 3.4120900630950928 seconds.\n", "(BENCH) Finished this code cell.\n" ] } ], "source": [ "import cmdline_helper as cmd\n", "CFL_FACTOR=1.0\n", "cmd.C_compile(os.path.join(Ccodesdir,\"BrillLindquist_Playground.c\"),\n", " os.path.join(outdir,\"BrillLindquist_Playground\"),compile_mode=\"optimized\")\n", "# cmd.C_compile(os.path.join(Ccodesdir,\"BrillLindquist_Playground.c\"),\n", "# os.path.join(outdir,\"BrillLindquist_Playground\"),compile_mode=\"custom\",\n", "# custom_compile_string=\"gcc -O2 -g -march=native \"+\n", "# os.path.join(Ccodesdir,\"BrillLindquist_Playground.c\")+\n", "# \" -o \"+os.path.join(outdir,\"BrillLindquist_Playground\")+\" -lm\")\n", "\n", "# Change to output directory\n", "os.chdir(outdir)\n", "# Clean up existing output files\n", "cmd.delete_existing_files(\"out*.txt\")\n", "cmd.delete_existing_files(\"out*.png\")\n", "# Run executable\n", "cmd.Execute(\"BrillLindquist_Playground\", \"72 12 2 \"+str(CFL_FACTOR))\n", "cmd.Execute(\"BrillLindquist_Playground\", \"96 16 2 \"+str(CFL_FACTOR))\n", "\n", "# Return to root directory\n", "os.chdir(os.path.join(\"../../\"))\n", "\n", "# with open(\"compilescript\", \"w\") as file:\n", "# count=0\n", "# for custom_compile_string0 in [\"-O2\",\"-O\",\"\"]:\n", "# for custom_compile_string1 in [\"\",\"-fp-model fast=2 -no-prec-div\"]:\n", "# for custom_compile_string2 in [\"\",\"-qopt-prefetch=3\",\"-qopt-prefetch=4\"]:\n", "# for custom_compile_string3 in [\"\",\"-unroll\"]:\n", "# for custom_compile_string4 in [\"\",\"-qoverride-limits\"]:\n", "# exc= \"BL\"+custom_compile_string0+custom_compile_string1.replace(\" \",\"\")+custom_compile_string2+custom_compile_string3+custom_compile_string4\n", "# ccs = \"icc -qopenmp -xHost \"+custom_compile_string0+\" \"+custom_compile_string1+\" \"+custom_compile_string2+\" \"+custom_compile_string3+\" \"+custom_compile_string4+\" BSSN_Two_BHs_Collide_Ccodes/BrillLindquist_Playground.c -o \"+exc\n", "# file.write(ccs+\" &\\n\")\n", "# if count>0 and count%16==0:\n", "# file.write(\"wait\\n\")\n", "# count += 1\n", "# file.write(\"wait\\n\")\n", "\n", "# with open(\"compilescriptgcc\", \"w\") as file:\n", "# count=0\n", "# for custom_compile_string0 in [\"-Ofast\",\"-O2\",\"-O3\",\"-O\",\"\"]:\n", "# for custom_compile_string1 in [\"-fopenmp\"]:\n", "# for custom_compile_string2 in [\"\",\"-march=native\"]:\n", "# for custom_compile_string3 in [\"\",\"-funroll-loops\",\"-funroll-all-loops\"]:\n", "# for custom_compile_string4 in [\"\"]:\n", "# exc= \"BL\"+custom_compile_string0+custom_compile_string1+custom_compile_string2+custom_compile_string3+custom_compile_string4\n", "# ccs = \"gcc \"+custom_compile_string0+\" \"+custom_compile_string1+\" \"+custom_compile_string2+\" \"+custom_compile_string3+\" \"+custom_compile_string4+\" BSSN_Two_BHs_Collide_Ccodes/BrillLindquist_Playground.c -o \"+exc\n", "# file.write(ccs+\" -lm &\\n\")\n", "# if count>0 and count%16==0:\n", "# file.write(\"wait\\n\")\n", "# count += 1\n", "# file.write(\"wait\\n\")\n", "\n", "\n", "print(\"(BENCH) Finished this code cell.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\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": [ "\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-03-07T17:29:50.468632Z", "iopub.status.busy": "2021-03-07T17:29:50.467521Z", "iopub.status.idle": "2021-03-07T17:29:51.531388Z", "shell.execute_reply": "2021-03-07T17:29:51.532076Z" }, "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 http://astro.phys.wvu.edu/zetienne/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": [ "\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-03-07T17:29:51.547373Z", "iopub.status.busy": "2021-03-07T17:29:51.546665Z", "iopub.status.idle": "2021-03-07T17:29:56.626427Z", "shell.execute_reply": "2021-03-07T17:29:56.626944Z" } }, "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 numpy as np\n", "from scipy.interpolate import griddata\n", "import matplotlib.pyplot as plt\n", "from matplotlib.pyplot import savefig\n", "from IPython.display import HTML\n", "import matplotlib.image as mgimg\n", "\n", "import glob\n", "import sys\n", "from matplotlib import animation\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", "bound=1.4\n", "pl_xmin = -bound\n", "pl_xmax = +bound\n", "pl_ymin = -bound\n", "pl_ymax = +bound\n", "\n", "for filename in file_list:\n", " fig = plt.figure()\n", " x,y,cf,Ham = np.loadtxt(filename).T #Transposed for easier unpacking\n", "\n", " plotquantity = cf\n", " plotdescription = \"Numerical Soln.\"\n", " plt.title(\"Black Hole Head-on Collision (conf factor)\")\n", " plt.xlabel(\"y/M\")\n", " plt.ylabel(\"z/M\")\n", "\n", " grid_x, grid_y = np.mgrid[pl_xmin:pl_xmax:300j, pl_ymin:pl_ymax:300j]\n", " points = np.zeros((len(x), 2))\n", " for i in range(len(x)):\n", " # Zach says: No idea why x and y get flipped...\n", " points[i][0] = y[i]\n", " points[i][1] = x[i]\n", "\n", " grid = griddata(points, plotquantity, (grid_x, grid_y), method='nearest')\n", " gridcub = griddata(points, plotquantity, (grid_x, grid_y), method='cubic')\n", " im = plt.imshow(gridcub, extent=(pl_xmin,pl_xmax, pl_ymin,pl_ymax))\n", " ax = plt.colorbar()\n", " ax.set_label(plotdescription)\n", " 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": [ "\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-03-07T17:29:56.760379Z", "iopub.status.busy": "2021-03-07T17:29:56.719430Z", "iopub.status.idle": "2021-03-07T17:29:58.227976Z", "shell.execute_reply": "2021-03-07T17:29:58.227374Z" } }, "outputs": [], "source": [ "## VISUALIZATION ANIMATION, PART 2: Combine PNGs to generate movie ##\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)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:29:58.232056Z", "iopub.status.busy": "2021-03-07T17:29:58.231397Z", "iopub.status.idle": "2021-03-07T17:29:58.234033Z", "shell.execute_reply": "2021-03-07T17:29:58.234592Z" } }, "outputs": [], "source": [ "## 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" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:29:58.242636Z", "iopub.status.busy": "2021-03-07T17:29:58.241878Z", "iopub.status.idle": "2021-03-07T17:29:58.245510Z", "shell.execute_reply": "2021-03-07T17:29:58.244994Z" }, "scrolled": true }, "outputs": [ { "data": { "text/html": [ "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Embed video based on suggestion:\n", "# https://stackoverflow.com/questions/39900173/jupyter-notebook-html-cell-magic-with-python-variable\n", "HTML(\"\"\"\n", "\n", "\"\"\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Step 8: Plot the numerical error, and confirm that it converges to zero with increasing numerical resolution (sampling) \\[Back to [top](#toc)\\]\n", "$$\\label{convergence}$$" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:29:58.276133Z", "iopub.status.busy": "2021-03-07T17:29:58.254573Z", "iopub.status.idle": "2021-03-07T17:29:58.722544Z", "shell.execute_reply": "2021-03-07T17:29:58.722013Z" }, "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x96,y96,valuesCF96,valuesHam96 = np.loadtxt(os.path.join(outdir,'out96.txt')).T #Transposed for easier unpacking\n", "\n", "pl_xmin = -2.5\n", "pl_xmax = +2.5\n", "pl_ymin = -2.5\n", "pl_ymax = +2.5\n", "\n", "grid_x, grid_y = np.mgrid[pl_xmin:pl_xmax:100j, pl_ymin:pl_ymax:100j]\n", "points96 = np.zeros((len(x96), 2))\n", "for i in range(len(x96)):\n", " points96[i][0] = x96[i]\n", " points96[i][1] = y96[i]\n", "\n", "grid96 = griddata(points96, valuesCF96, (grid_x, grid_y), method='nearest')\n", "grid96cub = griddata(points96, valuesCF96, (grid_x, grid_y), method='cubic')\n", "\n", "grid96 = griddata(points96, valuesHam96, (grid_x, grid_y), method='nearest')\n", "grid96cub = griddata(points96, valuesHam96, (grid_x, grid_y), method='cubic')\n", "\n", "# fig, ax = plt.subplots()\n", "\n", "plt.clf()\n", "plt.title(\"96x16 Num. Err.: log_{10}|Ham|\")\n", "plt.xlabel(\"x/M\")\n", "plt.ylabel(\"z/M\")\n", "\n", "fig96cub = plt.imshow(grid96cub.T, extent=(pl_xmin,pl_xmax, pl_ymin,pl_ymax))\n", "cb = plt.colorbar(fig96cub)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:29:58.747552Z", "iopub.status.busy": "2021-03-07T17:29:58.746925Z", "iopub.status.idle": "2021-03-07T17:29:58.966287Z", "shell.execute_reply": "2021-03-07T17:29:58.966766Z" }, "scrolled": false }, "outputs": [ { "data": { "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x72,y72,valuesCF72,valuesHam72 = np.loadtxt(os.path.join(outdir,'out72.txt')).T #Transposed for easier unpacking\n", "points72 = np.zeros((len(x72), 2))\n", "for i in range(len(x72)):\n", " points72[i][0] = x72[i]\n", " points72[i][1] = y72[i]\n", "\n", "grid72 = griddata(points72, valuesHam72, (grid_x, grid_y), method='nearest')\n", "\n", "griddiff_72_minus_96 = np.zeros((100,100))\n", "griddiff_72_minus_96_1darray = np.zeros(100*100)\n", "gridx_1darray_yeq0 = np.zeros(100)\n", "grid72_1darray_yeq0 = np.zeros(100)\n", "grid96_1darray_yeq0 = np.zeros(100)\n", "count = 0\n", "for i in range(100):\n", " for j in range(100):\n", " griddiff_72_minus_96[i][j] = grid72[i][j] - grid96[i][j]\n", " griddiff_72_minus_96_1darray[count] = griddiff_72_minus_96[i][j]\n", " if j==49:\n", " gridx_1darray_yeq0[i] = grid_x[i][j]\n", " grid72_1darray_yeq0[i] = grid72[i][j] + np.log10((72./96.)**4)\n", " grid96_1darray_yeq0[i] = grid96[i][j]\n", " count = count + 1\n", "\n", "plt.clf()\n", "fig, ax = plt.subplots()\n", "plt.title(\"4th-order Convergence, at t/M=7.5 (post-merger; horiz at x/M=+/-1)\")\n", "plt.xlabel(\"x/M\")\n", "plt.ylabel(\"log10(Relative error)\")\n", "\n", "ax.plot(gridx_1darray_yeq0, grid96_1darray_yeq0, 'k-', label='Nr=96')\n", "ax.plot(gridx_1darray_yeq0, grid72_1darray_yeq0, '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": [ "\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": 21, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:29:58.971437Z", "iopub.status.busy": "2021-03-07T17:29:58.970705Z", "iopub.status.idle": "2021-03-07T17:30:04.091527Z", "shell.execute_reply": "2021-03-07T17:30:04.092219Z" } }, "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.10.0rc2" } }, "nbformat": 4, "nbformat_minor": 2 }