{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Converting between the 4-metric $g_{\\mu\\nu}$ and ADM variables $\\left\\{\\gamma_{ij}, \\alpha, \\beta^i\\right\\}$ or BSSN variables $\\left\\{h_{ij}, {\\rm cf}, \\alpha, {\\rm vet}^i\\right\\}$\n", "## Author: Zach Etienne\n", "\n", "[comment]: <> (Abstract: TODO)\n", "\n", "### We will often find it useful to convert between the 4-metric $g_{\\mu\\nu}$ and the ADM or BSSN variables. This notebook documents the NRPy+ Python module [`BSSN.ADMBSSN_tofrom_4metric`](../edit/BSSN/ADMBSSN_tofrom_4metric.py), which provides that functionality.\n", "\n", "**Notebook Status:** Self-validated, some additional tests performed \n", "\n", "**Validation Notes:** This tutorial notebook has been confirmed to be self-consistent with its corresponding NRPy+ module, as documented [below](#code_validation). In addition, the construction of $g_{\\mu\\nu}$ and $g^{\\mu\\nu}$ from BSSN variables has passed the test $g^{\\mu\\nu}g_{\\mu\\nu}=4$ [below](#validationcontraction). **Additional validation tests may have been performed, but are as yet, undocumented. (TODO)**\n", "\n", "### NRPy+ Source Code for this module: [BSSN/ADMBSSN_tofrom_4metric.py](../edit/BSSN/ADMBSSN_tofrom_4metric.py)\n", "\n", "## Introduction:\n" ] }, { "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](#setup_ADM_quantities): `setup_ADM_quantities(inputvars)`: If `inputvars=\"ADM\"` declare ADM quantities $\\left\\{\\gamma_{ij},\\beta^i,\\alpha\\right\\}$; if `inputvars=\"ADM\"` define ADM quantities in terms of BSSN quantities\n", "1. [Step 2](#admbssn_to_fourmetric): Write 4-metric $g_{\\mu\\nu}$ and its inverse $g^{\\mu\\nu}$ in terms of ADM or BSSN quantities\n", " 1. [Step 2.a](#admbssn_to_fourmetric_lower): 4-metric $g_{\\mu\\nu}$ in terms of ADM or BSSN quantities\n", " 1. [Step 2.b](#admbssn_to_fourmetric_inv): 4-metric inverse $g^{\\mu\\nu}$ in terms of ADM or BSSN quantities\n", " 1. [Step 2.c](#validationcontraction): Validation check: Confirm $g_{\\mu\\nu}g^{\\mu\\nu}=4$\n", "1. [Step 3](#fourmetric_to_admbssn): Write ADM/BSSN metric quantities in terms of 4-metric $g_{\\mu\\nu}$ (Excludes extrinsic curvature $K_{ij}$ or the BSSN $\\bar{A}_{ij}$, $K$)\n", " 1. [Step 3.a](#adm_ito_fourmetric_validate): ADM in terms of 4-metric validation: Confirm $\\gamma_{ij}\\gamma^{ij}=3$\n", " 1. [Step 3.b](#bssn_ito_fourmetric_validate): BSSN in terms of 4-metric validation: Confirm $\\bar{\\gamma}_{ij}\\bar{\\gamma}^{ij}=3$\n", "1. [Step 4](#code_validation): Code Validation against `BSSN.ADMBSSN_tofrom_4metric` NRPy+ module\n", "1. [Step 5](#latex_pdf_output): Output this notebook to $\\LaTeX$-formatted PDF file" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Step 1: `setup_ADM_quantities(inputvars)`: If `inputvars=\"ADM\"` declare ADM quantities $\\left\\{\\gamma_{ij},\\beta^i,\\alpha\\right\\}$; if `inputvars=\"ADM\"` define ADM quantities in terms of BSSN quantities \\[Back to [top](#toc)\\]\n", "$$\\label{setup_ADM_quantities}$$" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:04:53.262855Z", "iopub.status.busy": "2021-03-07T17:04:53.261631Z", "iopub.status.idle": "2021-03-07T17:04:53.587660Z", "shell.execute_reply": "2021-03-07T17:04:53.586941Z" } }, "outputs": [], "source": [ "import sympy as sp\n", "import NRPy_param_funcs as par\n", "import indexedexp as ixp\n", "import sys\n", "\n", "def setup_ADM_quantities(inputvars):\n", " if inputvars == \"ADM\":\n", " gammaDD = ixp.declarerank2(\"gammaDD\", \"sym01\")\n", " betaU = ixp.declarerank1(\"betaU\")\n", " alpha = sp.symbols(\"alpha\", real=True)\n", " elif inputvars == \"BSSN\":\n", " import BSSN.ADM_in_terms_of_BSSN as AitoB\n", "\n", " # Construct gamma_{ij} in terms of cf & gammabar_{ij}\n", " AitoB.ADM_in_terms_of_BSSN()\n", " gammaDD = AitoB.gammaDD\n", " # Next construct beta^i in terms of vet^i and reference metric quantities\n", " import BSSN.BSSN_quantities as Bq\n", "\n", " Bq.BSSN_basic_tensors()\n", " betaU = Bq.betaU\n", " alpha = sp.symbols(\"alpha\", real=True)\n", " else:\n", " print(\"inputvars = \" + str(inputvars) + \" not supported. Please choose ADM or BSSN.\")\n", " sys.exit(1)\n", " return gammaDD,betaU,alpha" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Step 2: Write 4-metric $g_{\\mu\\nu}$ and its inverse $g^{\\mu\\nu}$ in terms of ADM or BSSN variables \\[Back to [top](#toc)\\]\n", "$$\\label{admbssn_to_fourmetric}$$\n", "\n", "\n", "\n", "## Step 2.a: 4-metric $g_{\\mu\\nu}$ in terms of ADM or BSSN variables \\[Back to [top](#toc)\\]\n", "$$\\label{admbssn_to_fourmetric_lower}$$\n", "\n", "Given ADM variables $\\left\\{\\gamma_{ij},\\beta^i,\\alpha \\right\\}$, which themselves may be written in terms of the rescaled BSSN curvilinear variables $\\left\\{h_{ij},{\\rm cf},\\mathcal{V}^i,\\alpha \\right\\}$ for our chosen reference metric via simple function calls to `ADM_in_terms_of_BSSN()` and `BSSN_quantities.BSSN_basic_tensors()`, we are to construct the 4-metric $g_{\\mu\\nu}$. \n", "\n", "We accomplish this via Eq. 2.122 (which can be trivially derived from the ADM 3+1 line element) of Baumgarte & Shapiro's *Numerical Relativity* (henceforth B&S):\n", "$$\n", "g_{\\mu\\nu} = \\begin{pmatrix} \n", "-\\alpha^2 + \\beta^k \\beta_k & \\beta_i \\\\\n", "\\beta_j & \\gamma_{ij}\n", "\\end{pmatrix},\n", "$$\n", "where the shift vector $\\beta^i$ is lowered via (Eq. 2.121):\n", "\n", "$$\\beta_k = \\gamma_{ik} \\beta^i.$$" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:04:53.597249Z", "iopub.status.busy": "2021-03-07T17:04:53.596001Z", "iopub.status.idle": "2021-03-07T17:04:53.598438Z", "shell.execute_reply": "2021-03-07T17:04:53.598945Z" } }, "outputs": [], "source": [ "def g4DD_ito_BSSN_or_ADM(inputvars):\n", " # Step 0: Declare g4DD as globals, to make interfacing with other modules/functions easier\n", " global g4DD\n", "\n", " # Step 1: Check that inputvars is set to a supported value\n", " gammaDD,betaU,alpha = setup_ADM_quantities(inputvars)\n", "\n", " # Step 2: Compute g4DD = g_{mu nu}:\n", " # To get \\gamma_{\\mu \\nu} = gamma4DD[mu][nu], we'll need to construct the 4-metric, using Eq. 2.122 in B&S:\n", " g4DD = ixp.zerorank2(DIM=4)\n", "\n", " # Step 2.a: Compute beta_i via Eq. 2.121 in B&S\n", " betaD = ixp.zerorank1()\n", " for i in range(3):\n", " for j in range(3):\n", " betaD[i] += gammaDD[i][j] * betaU[j]\n", "\n", " # Step 2.b: Compute beta_i beta^i, the beta contraction.\n", " beta2 = sp.sympify(0)\n", " for i in range(3):\n", " beta2 += betaU[i] * betaD[i]\n", "\n", " # Step 2.c: Construct g4DD via Eq. 2.122 in B&S\n", " g4DD[0][0] = -alpha ** 2 + beta2\n", " for mu in range(1, 4):\n", " g4DD[mu][0] = g4DD[0][mu] = betaD[mu - 1]\n", " for mu in range(1, 4):\n", " for nu in range(1, 4):\n", " g4DD[mu][nu] = gammaDD[mu - 1][nu - 1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Step 2.b: Inverse 4-metric $g^{\\mu\\nu}$ in terms of ADM or BSSN variables \\[Back to [top](#toc)\\]\n", "$$\\label{admbssn_to_fourmetric_inv}$$ \n", "\n", "B&S also provide a convenient form for the inverse 4-metric (Eq. 2.119; also Eq. 4.49 in [Gourgoulhon](https://arxiv.org/pdf/gr-qc/0703035.pdf)):\n", "$$\n", "g^{\\mu\\nu} = \\gamma^{\\mu\\nu} - n^\\mu n^\\nu = \n", "\\begin{pmatrix} \n", "-\\frac{1}{\\alpha^2} & \\frac{\\beta^i}{\\alpha^2} \\\\\n", "\\frac{\\beta^i}{\\alpha^2} & \\gamma^{ij} - \\frac{\\beta^i\\beta^j}{\\alpha^2}\n", "\\end{pmatrix},\n", "$$\n", "where the unit normal vector to the hypersurface is given by $n^{\\mu} = \\left(\\alpha^{-1},-\\beta^i/\\alpha\\right)$." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:04:53.606601Z", "iopub.status.busy": "2021-03-07T17:04:53.605941Z", "iopub.status.idle": "2021-03-07T17:04:53.608043Z", "shell.execute_reply": "2021-03-07T17:04:53.608578Z" } }, "outputs": [], "source": [ "def g4UU_ito_BSSN_or_ADM(inputvars):\n", " # Step 0: Declare g4UU as globals, to make interfacing with other modules/functions easier\n", " global g4UU\n", "\n", " # Step 1: Check that inputvars is set to a supported value\n", " gammaDD,betaU,alpha = setup_ADM_quantities(inputvars)\n", "\n", " # Step 2: Compute g4UU = g_{mu nu}:\n", " # To get \\gamma^{\\mu \\nu} = gamma4UU[mu][nu], we'll need to use Eq. 2.119 in B&S.\n", " g4UU = ixp.zerorank2(DIM=4)\n", "\n", " # Step 3: Construct g4UU = g^{mu nu}\n", " # Step 3.a: Compute gammaUU based on provided gammaDD:\n", " gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaDD)\n", "\n", " # Then evaluate g4UU:\n", " g4UU = ixp.zerorank2(DIM=4)\n", "\n", " g4UU[0][0] = -1 / alpha**2\n", " for mu in range(1,4):\n", " g4UU[0][mu] = g4UU[mu][0] = betaU[mu-1]/alpha**2\n", " for mu in range(1,4):\n", " for nu in range(1,4):\n", " g4UU[mu][nu] = gammaUU[mu-1][nu-1] - betaU[mu-1]*betaU[nu-1]/alpha**2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Step 2.c: Validation check: Confirm $g_{\\mu\\nu}g^{\\mu\\nu}=4$ \\[Back to [top](#toc)\\]\n", "$$\\label{validationcontraction}$$ \n", "\n", "Next we compute $g^{\\mu\\nu} g_{\\mu\\nu}$ as a validation check. It should equal 4:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:04:53.614947Z", "iopub.status.busy": "2021-03-07T17:04:53.613945Z", "iopub.status.idle": "2021-03-07T17:04:55.800662Z", "shell.execute_reply": "2021-03-07T17:04:55.801196Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "TEST PASSED!\n" ] } ], "source": [ "g4DD_ito_BSSN_or_ADM(\"BSSN\")\n", "g4UU_ito_BSSN_or_ADM(\"BSSN\")\n", "sum = 0\n", "for mu in range(4):\n", " for nu in range(4):\n", " sum += g4DD[mu][nu]*g4UU[mu][nu]\n", "if sp.simplify(sum) == sp.sympify(4):\n", " print(\"TEST PASSED!\")\n", "else:\n", " print(\"TEST FAILED: \"+str(sum)+\" does not apparently equal 4.\")\n", " sys.exit(1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Step 3: Write ADM/BSSN metric quantities in terms of 4-metric $g_{\\mu\\nu}$ (Excludes extrinsic curvature $K_{ij}$, the BSSN $a_{ij}$, $K$, and $\\lambda^i$) \\[Back to [top](#toc)\\]\n", "$$\\label{fourmetric_to_admbssn}$$ \n", "\n", "Given $g_{\\mu\\nu}$, we now compute ADM/BSSN metric quantities, excluding extrinsic curvature. \n", "\n", "Let's start by computing the ADM quantities in terms of the 4-metric $g_{\\mu\\nu}$\n", "\n", "Recall that\n", "$$\n", "g_{\\mu\\nu} = \\begin{pmatrix} \n", "-\\alpha^2 + \\beta^k \\beta_k & \\beta_i \\\\\n", "\\beta_j & \\gamma_{ij}\n", "\\end{pmatrix}.\n", "$$\n", "\n", "From this equation we immediately obtain $\\gamma_{ij}$. However we need $\\beta^i$ and $\\alpha$. After computing the inverse of $\\gamma_{ij}$, $\\gamma^{ij}$, we raise $\\beta_j$ via $\\beta^i=\\gamma^{ij} \\beta_j$ and then compute $\\alpha$ via $\\alpha = \\sqrt{\\beta^k \\beta_k - g_{00}}$. To convert to BSSN variables $\\left\\{h_{ij},{\\rm cf},\\mathcal{V}^i,\\alpha \\right\\}$, we need only convert from ADM via function calls to [`BSSN.BSSN_in_terms_of_ADM`](../edit/BSSN/BSSN_in_terms_of_ADM.py) ([**tutorial**](Tutorial-BSSN_in_terms_of_ADM.ipynb))." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:04:55.812488Z", "iopub.status.busy": "2021-03-07T17:04:55.811792Z", "iopub.status.idle": "2021-03-07T17:04:55.814035Z", "shell.execute_reply": "2021-03-07T17:04:55.814668Z" } }, "outputs": [], "source": [ "def BSSN_or_ADM_ito_g4DD(inputvars):\n", " # Step 0: Declare output variables as globals, to make interfacing with other modules/functions easier\n", " if inputvars == \"ADM\":\n", " global gammaDD,betaU,alpha\n", " elif inputvars == \"BSSN\":\n", " global hDD,cf,vetU,alpha\n", " else:\n", " print(\"inputvars = \" + str(inputvars) + \" not supported. Please choose ADM or BSSN.\")\n", " sys.exit(1)\n", "\n", " # Step 1: declare g4DD as symmetric rank-4 tensor:\n", " g4DD = ixp.declarerank2(\"g4DD\",\"sym01\",DIM=4)\n", "\n", " # Step 2: Compute gammaDD & betaD\n", " betaD = ixp.zerorank1()\n", " gammaDD = ixp.zerorank2()\n", " for i in range(3):\n", " betaD[i] = g4DD[0][i]\n", " for j in range(3):\n", " gammaDD[i][j] = g4DD[i+1][j+1]\n", "\n", " # Step 3: Compute betaU\n", " # Step 3.a: Compute gammaUU based on provided gammaDD\n", " gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaDD)\n", "\n", " # Step 3.b: Use gammaUU to raise betaU\n", " betaU = ixp.zerorank1()\n", " for i in range(3):\n", " for j in range(3):\n", " betaU[i] += gammaUU[i][j]*betaD[j]\n", "\n", " # Step 4: Compute alpha = sqrt(beta^2 - g_{00}):\n", " # Step 4.a: Compute beta^2 = beta^k beta_k:\n", " beta_squared = sp.sympify(0)\n", " for k in range(3):\n", " beta_squared += betaU[k]*betaD[k]\n", "\n", " # Step 4.b: alpha = sqrt(beta^2 - g_{00}):\n", " alpha = sp.sqrt(sp.simplify(beta_squared) - g4DD[0][0])\n", "\n", " # Step 5: If inputvars == \"ADM\", we are finished. Return.\n", " if inputvars == \"ADM\":\n", " return\n", "\n", " # Step 6: If inputvars == \"BSSN\", convert ADM to BSSN & return hDD, cf,\n", " import BSSN.BSSN_in_terms_of_ADM as BitoA\n", " dummyBU = ixp.zerorank1()\n", " BitoA.gammabarDD_hDD( gammaDD)\n", " BitoA.cf_from_gammaDD(gammaDD)\n", " BitoA.betU_vetU( betaU,dummyBU)\n", " hDD = BitoA.hDD\n", " cf = BitoA.cf\n", " vetU = BitoA.vetU" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Step 3.a: ADM in terms of 4-metric validation: Confirm $\\gamma_{ij}\\gamma^{ij}=3$ \\[Back to [top](#toc)\\]\n", "$$\\label{adm_ito_fourmetric_validate}$$\n", "\n", "Next we compute $\\gamma^{ij} \\gamma_{ij}$ as a validation check. It should equal 3:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:04:55.889436Z", "iopub.status.busy": "2021-03-07T17:04:55.853637Z", "iopub.status.idle": "2021-03-07T17:04:56.239195Z", "shell.execute_reply": "2021-03-07T17:04:56.239674Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "TEST PASSED!\n" ] } ], "source": [ "BSSN_or_ADM_ito_g4DD(\"ADM\")\n", "gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaDD)\n", "\n", "sum = sp.sympify(0)\n", "for i in range(3):\n", " for j in range(3):\n", " sum += gammaDD[i][j]*gammaUU[i][j]\n", "if sp.simplify(sum) == sp.sympify(3):\n", " print(\"TEST PASSED!\")\n", "else:\n", " print(\"TEST FAILED: \"+str(sum)+\" does not apparently equal 3.\")\n", " sys.exit(1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Step 3.b: BSSN in terms of 4-metric validation: Confirm $\\bar{\\gamma}_{ij}\\bar{\\gamma}^{ij}=3$ \\[Back to [top](#toc)\\]\n", "$$\\label{bssn_ito_fourmetric_validate}$$\n", "\n", "Next we compute $\\bar{\\gamma}_{ij}\\bar{\\gamma}^{ij}$ as a validation check. It should equal 3:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:04:56.314333Z", "iopub.status.busy": "2021-03-07T17:04:56.278451Z", "iopub.status.idle": "2021-03-07T17:05:00.367571Z", "shell.execute_reply": "2021-03-07T17:05:00.366908Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "TEST PASSED!\n" ] } ], "source": [ "import reference_metric as rfm\n", "par.set_parval_from_str(\"reference_metric::CoordSystem\",\"SinhCylindrical\")\n", "rfm.reference_metric()\n", "\n", "BSSN_or_ADM_ito_g4DD(\"BSSN\")\n", "gammabarDD = ixp.zerorank2()\n", "for i in range(3):\n", " for j in range(3):\n", " # gammabar_{ij} = h_{ij}*ReDD[i][j] + gammahat_{ij}\n", " gammabarDD[i][j] = hDD[i][j] * rfm.ReDD[i][j] + rfm.ghatDD[i][j]\n", "\n", "gammabarUU, gammabarDET = ixp.symm_matrix_inverter3x3(gammabarDD)\n", "\n", "sum = sp.sympify(0)\n", "for i in range(3):\n", " for j in range(3):\n", " sum += gammabarDD[i][j]*gammabarUU[i][j]\n", "if sp.simplify(sum) == sp.sympify(3):\n", " print(\"TEST PASSED!\")\n", "else:\n", " print(\"TEST FAILED: \"+str(sum)+\" does not apparently equal 3.\")\n", " sys.exit(1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## Step 4: Code Validation against `BSSN.ADMBSSN_tofrom_4metric` NRPy+ module \\[Back to [top](#toc)\\]\n", "$$\\label{code_validation}$$\n", "\n", "Here, as a code validation check, we verify agreement in the SymPy expressions for BrillLindquist initial data between\n", "1. this tutorial and \n", "2. the NRPy+ [BSSN.ADMBSSN_tofrom_4metric](../edit/BSSN/ADMBSSN_tofrom_4metric.py) module.\n", "\n", "By default, we analyze these expressions in SinhCylindrical coordinates, though other coordinate systems may be chosen." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:05:00.432621Z", "iopub.status.busy": "2021-03-07T17:05:00.401943Z", "iopub.status.idle": "2021-03-07T17:05:04.663656Z", "shell.execute_reply": "2021-03-07T17:05:04.664220Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "BSSN input: g4DD[0][0] - g4DD_mod[0][0] = 0\n", "BSSN input: g4DD[0][1] - g4DD_mod[0][1] = 0\n", "BSSN input: g4DD[0][2] - g4DD_mod[0][2] = 0\n", "BSSN input: g4DD[0][3] - g4DD_mod[0][3] = 0\n", "BSSN input: g4DD[1][0] - g4DD_mod[1][0] = 0\n", "BSSN input: g4DD[1][1] - g4DD_mod[1][1] = 0\n", "BSSN input: g4DD[1][2] - g4DD_mod[1][2] = 0\n", "BSSN input: g4DD[1][3] - g4DD_mod[1][3] = 0\n", "BSSN input: g4DD[2][0] - g4DD_mod[2][0] = 0\n", "BSSN input: g4DD[2][1] - g4DD_mod[2][1] = 0\n", "BSSN input: g4DD[2][2] - g4DD_mod[2][2] = 0\n", "BSSN input: g4DD[2][3] - g4DD_mod[2][3] = 0\n", "BSSN input: g4DD[3][0] - g4DD_mod[3][0] = 0\n", "BSSN input: g4DD[3][1] - g4DD_mod[3][1] = 0\n", "BSSN input: g4DD[3][2] - g4DD_mod[3][2] = 0\n", "BSSN input: g4DD[3][3] - g4DD_mod[3][3] = 0\n", "BSSN input: g4UU[0][0] - g4UU_mod[0][0] = 0\n", "BSSN input: g4UU[0][1] - g4UU_mod[0][1] = 0\n", "BSSN input: g4UU[0][2] - g4UU_mod[0][2] = 0\n", "BSSN input: g4UU[0][3] - g4UU_mod[0][3] = 0\n", "BSSN input: g4UU[1][0] - g4UU_mod[1][0] = 0\n", "BSSN input: g4UU[1][1] - g4UU_mod[1][1] = 0\n", "BSSN input: g4UU[1][2] - g4UU_mod[1][2] = 0\n", "BSSN input: g4UU[1][3] - g4UU_mod[1][3] = 0\n", "BSSN input: g4UU[2][0] - g4UU_mod[2][0] = 0\n", "BSSN input: g4UU[2][1] - g4UU_mod[2][1] = 0\n", "BSSN input: g4UU[2][2] - g4UU_mod[2][2] = 0\n", "BSSN input: g4UU[2][3] - g4UU_mod[2][3] = 0\n", "BSSN input: g4UU[3][0] - g4UU_mod[3][0] = 0\n", "BSSN input: g4UU[3][1] - g4UU_mod[3][1] = 0\n", "BSSN input: g4UU[3][2] - g4UU_mod[3][2] = 0\n", "BSSN input: g4UU[3][3] - g4UU_mod[3][3] = 0\n", "ADM input: g4DD[0][0] - g4DD_mod[0][0] = 0\n", "ADM input: g4DD[0][1] - g4DD_mod[0][1] = 0\n", "ADM input: g4DD[0][2] - g4DD_mod[0][2] = 0\n", "ADM input: g4DD[0][3] - g4DD_mod[0][3] = 0\n", "ADM input: g4DD[1][0] - g4DD_mod[1][0] = 0\n", "ADM input: g4DD[1][1] - g4DD_mod[1][1] = 0\n", "ADM input: g4DD[1][2] - g4DD_mod[1][2] = 0\n", "ADM input: g4DD[1][3] - g4DD_mod[1][3] = 0\n", "ADM input: g4DD[2][0] - g4DD_mod[2][0] = 0\n", "ADM input: g4DD[2][1] - g4DD_mod[2][1] = 0\n", "ADM input: g4DD[2][2] - g4DD_mod[2][2] = 0\n", "ADM input: g4DD[2][3] - g4DD_mod[2][3] = 0\n", "ADM input: g4DD[3][0] - g4DD_mod[3][0] = 0\n", "ADM input: g4DD[3][1] - g4DD_mod[3][1] = 0\n", "ADM input: g4DD[3][2] - g4DD_mod[3][2] = 0\n", "ADM input: g4DD[3][3] - g4DD_mod[3][3] = 0\n", "ADM input: g4UU[0][0] - g4UU_mod[0][0] = 0\n", "ADM input: g4UU[0][1] - g4UU_mod[0][1] = 0\n", "ADM input: g4UU[0][2] - g4UU_mod[0][2] = 0\n", "ADM input: g4UU[0][3] - g4UU_mod[0][3] = 0\n", "ADM input: g4UU[1][0] - g4UU_mod[1][0] = 0\n", "ADM input: g4UU[1][1] - g4UU_mod[1][1] = 0\n", "ADM input: g4UU[1][2] - g4UU_mod[1][2] = 0\n", "ADM input: g4UU[1][3] - g4UU_mod[1][3] = 0\n", "ADM input: g4UU[2][0] - g4UU_mod[2][0] = 0\n", "ADM input: g4UU[2][1] - g4UU_mod[2][1] = 0\n", "ADM input: g4UU[2][2] - g4UU_mod[2][2] = 0\n", "ADM input: g4UU[2][3] - g4UU_mod[2][3] = 0\n", "ADM input: g4UU[3][0] - g4UU_mod[3][0] = 0\n", "ADM input: g4UU[3][1] - g4UU_mod[3][1] = 0\n", "ADM input: g4UU[3][2] - g4UU_mod[3][2] = 0\n", "ADM input: g4UU[3][3] - g4UU_mod[3][3] = 0\n", "BSSN QUANTITIES (ito 4-metric g4DD)\n", "cf - mod_cf = 0\n", "alpha - mod_alpha = 0\n", "vetU[0] - mod_vetU[0] = 0\n", "hDD[0][0] - mod_hDD[0][0] = 0\n", "hDD[0][1] - mod_hDD[0][1] = 0\n", "hDD[0][2] - mod_hDD[0][2] = 0\n", "vetU[1] - mod_vetU[1] = 0\n", "hDD[1][0] - mod_hDD[1][0] = 0\n", "hDD[1][1] - mod_hDD[1][1] = 0\n", "hDD[1][2] - mod_hDD[1][2] = 0\n", "vetU[2] - mod_vetU[2] = 0\n", "hDD[2][0] - mod_hDD[2][0] = 0\n", "hDD[2][1] - mod_hDD[2][1] = 0\n", "hDD[2][2] - mod_hDD[2][2] = 0\n", "ADM QUANTITIES (ito 4-metric g4DD)\n", "alpha - mod_alpha = 0\n", "betaU[0] - mod_betaU[0] = 0\n", "gammaDD[0][0] - mod_gammaDD[0][0] = 0\n", "gammaDD[0][1] - mod_gammaDD[0][1] = 0\n", "gammaDD[0][2] - mod_gammaDD[0][2] = 0\n", "betaU[1] - mod_betaU[1] = 0\n", "gammaDD[1][0] - mod_gammaDD[1][0] = 0\n", "gammaDD[1][1] - mod_gammaDD[1][1] = 0\n", "gammaDD[1][2] - mod_gammaDD[1][2] = 0\n", "betaU[2] - mod_betaU[2] = 0\n", "gammaDD[2][0] - mod_gammaDD[2][0] = 0\n", "gammaDD[2][1] - mod_gammaDD[2][1] = 0\n", "gammaDD[2][2] - mod_gammaDD[2][2] = 0\n" ] } ], "source": [ "par.set_parval_from_str(\"reference_metric::CoordSystem\",\"SinhCylindrical\")\n", "rfm.reference_metric()\n", "\n", "import BSSN.ADMBSSN_tofrom_4metric as AB4m\n", "for inputvars in [\"BSSN\",\"ADM\"]:\n", " g4DD_ito_BSSN_or_ADM(inputvars)\n", " AB4m.g4DD_ito_BSSN_or_ADM(inputvars)\n", " for i in range(4):\n", " for j in range(4):\n", " print(inputvars+\" input: g4DD[\"+str(i)+\"][\"+str(j)+\"] - g4DD_mod[\"+str(i)+\"][\"\n", " +str(j)+\"] = \"+str(g4DD[i][j]-AB4m.g4DD[i][j]))\n", "\n", " g4UU_ito_BSSN_or_ADM(inputvars)\n", " AB4m.g4UU_ito_BSSN_or_ADM(inputvars)\n", " for i in range(4):\n", " for j in range(4):\n", " print(inputvars+\" input: g4UU[\"+str(i)+\"][\"+str(j)+\"] - g4UU_mod[\"+str(i)+\"][\"\n", " +str(j)+\"] = \"+str(g4UU[i][j]-AB4m.g4UU[i][j]))\n", "\n", "BSSN_or_ADM_ito_g4DD(\"BSSN\")\n", "AB4m.BSSN_or_ADM_ito_g4DD(\"BSSN\")\n", "print(\"BSSN QUANTITIES (ito 4-metric g4DD)\")\n", "print(\"cf - mod_cf = \" + str(cf - AB4m.cf))\n", "print(\"alpha - mod_alpha = \" + str(alpha - AB4m.alpha))\n", "for i in range(3):\n", " print(\"vetU[\"+str(i)+\"] - mod_vetU[\"+str(i)+\"] = \" + str(vetU[i] - AB4m.vetU[i]))\n", " for j in range(3):\n", " print(\"hDD[\"+str(i)+\"][\"+str(j)+\"] - mod_hDD[\"+str(i)+\"][\"+str(j)+\"] = \"\n", " + str(hDD[i][j] - AB4m.hDD[i][j]))\n", "\n", "BSSN_or_ADM_ito_g4DD(\"ADM\")\n", "AB4m.BSSN_or_ADM_ito_g4DD(\"ADM\")\n", "print(\"ADM QUANTITIES (ito 4-metric g4DD)\")\n", "print(\"alpha - mod_alpha = \" + str(alpha - AB4m.alpha))\n", "for i in range(3):\n", " print(\"betaU[\"+str(i)+\"] - mod_betaU[\"+str(i)+\"] = \" + str(betaU[i] - AB4m.betaU[i]))\n", " for j in range(3):\n", " print(\"gammaDD[\"+str(i)+\"][\"+str(j)+\"] - mod_gammaDD[\"+str(i)+\"][\"+str(j)+\"] = \"\n", " + str(gammaDD[i][j] - AB4m.gammaDD[i][j]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Step 4: Output this notebook to $\\LaTeX$-formatted PDF file \\[Back to [top](#toc)\\]\n", "$$\\label{latex_pdf_output}$$\n", "\n", "The following code cell converts this Jupyter notebook into a proper, clickable $\\LaTeX$-formatted PDF file. After the cell is successfully run, the generated PDF may be found in the root NRPy+ tutorial directory, with filename [Tutorial-ADMBSSN_tofrom_4metric.pdf](Tutorial-ADMBSSN_tofrom_4metric.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": 9, "metadata": { "execution": { "iopub.execute_input": "2021-03-07T17:05:04.671046Z", "iopub.status.busy": "2021-03-07T17:05:04.668211Z", "iopub.status.idle": "2021-03-07T17:05:08.160672Z", "shell.execute_reply": "2021-03-07T17:05:08.161500Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Created Tutorial-ADMBSSN_tofrom_4metric.tex, and compiled LaTeX file to PDF\n", " file Tutorial-ADMBSSN_tofrom_4metric.pdf\n" ] } ], "source": [ "import cmdline_helper as cmd # NRPy+: Multi-platform Python command-line interface\n", "cmd.output_Jupyter_notebook_to_LaTeXed_PDF(\"Tutorial-ADMBSSN_tofrom_4metric\")" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.2" } }, "nbformat": 4, "nbformat_minor": 2 }