{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<script async src=\"https://www.googletagmanager.com/gtag/js?id=UA-59152712-8\"></script>\n",
"<script>\n",
" window.dataLayer = window.dataLayer || [];\n",
" function gtag(){dataLayer.push(arguments);}\n",
" gtag('js', new Date());\n",
"\n",
" gtag('config', 'UA-59152712-8');\n",
"</script>\n",
"\n",
"# 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",
"## This notebook presents the NRPy+ Python module [BSSN/ADMBSSN_tofrom_4metric.py](../edit/BSSN/ADMBSSN_tofrom_4metric.py), which facilitates conversion between the 4-metric and ADM or BSSN variables. The notebook also outlines the steps to write ADM/BSSN metric quantities in terms of 4-metric $g_{\\mu\\nu}$, while excluding extrinsic curvature $K_{ij}$, or the BSSN $\\bar{A}_{ij}$, $K$.\n",
"\n",
"**Notebook Status:** <font color='orange'><b> Self-validated, some additional tests performed </b></font>\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",
"[comment]: <> (Introduction: TODO)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='toc'></a>\n",
"\n",
"# Table of Contents\n",
"$$\\label{toc}$$ \n",
"\n",
"This notebook is organized as follows\n",
"\n",
"1. [Step 1](#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": [
"<a id='setup_ADM_quantities'></a>\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": [
"<a id='admbssn_to_fourmetric'></a>\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",
"<a id='admbssn_to_fourmetric_lower'></a>\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": [
"<a id='admbssn_to_fourmetric_inv'></a>\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": [
"<a id='validationcontraction'></a>\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",
"contraction = 0\n",
"for mu in range(4):\n",
" for nu in range(4):\n",
" contraction += g4DD[mu][nu]*g4UU[mu][nu]\n",
"if sp.simplify(contraction) == sp.sympify(4):\n",
" print(\"TEST PASSED!\")\n",
"else:\n",
" print(\"TEST FAILED: \"+str(contraction)+\" does not apparently equal 4.\")\n",
" sys.exit(1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='fourmetric_to_admbssn'></a>\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": [
"<a id='adm_ito_fourmetric_validate'></a>\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",
"contraction = sp.sympify(0)\n",
"for i in range(3):\n",
" for j in range(3):\n",
" contraction += gammaDD[i][j]*gammaUU[i][j]\n",
"if sp.simplify(contraction) == sp.sympify(3):\n",
" print(\"TEST PASSED!\")\n",
"else:\n",
" print(\"TEST FAILED: \"+str(contraction)+\" does not apparently equal 3.\")\n",
" sys.exit(1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='bssn_ito_fourmetric_validate'></a>\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",
"contraction = sp.sympify(0)\n",
"for i in range(3):\n",
" for j in range(3):\n",
" contraction += gammabarDD[i][j]*gammabarUU[i][j]\n",
"if sp.simplify(contraction) == sp.sympify(3):\n",
" print(\"TEST PASSED!\")\n",
"else:\n",
" print(\"TEST FAILED: \"+str(contraction)+\" does not apparently equal 3.\")\n",
" sys.exit(1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a id='code_validation'></a>\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": [
"<a id='latex_pdf_output'></a>\n",
"\n",
"# Step 4: Output this notebook to $\\LaTeX$-formatted PDF file \\[Back to [top](#toc)\\]\n",
"$$\\label{latex_pdf_output}$$\n",
"\n",
"The following code cell converts this Jupyter notebook into a proper, clickable $\\LaTeX$-formatted PDF file. After the cell is successfully run, the generated PDF may be found in the root NRPy+ tutorial directory, with filename [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": 1,
"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 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.1"
}
},
"nbformat": 4,
"nbformat_minor": 4
}