IllinoisGRMHD/doc/Tutorial-IllinoisGRMHD__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<script async src=\"https://www.googletagmanager.com/gtag/js?id=UA-59152712-8\"></script>\n",
    "<script>\n",
    "  window.dataLayer = window.dataLayer || [];\n",
    "  function gtag(){dataLayer.push(arguments);}\n",
    "  gtag('js', new Date());\n",
    "\n",
    "  gtag('config', 'UA-59152712-8');\n",
    "</script>\n",
    "\n",
    "# Tutorial-IllinoisGRMHD: compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.C\n",
    "\n",
    "## Authors: Leo Werneck & Zach Etienne\n",
    "\n",
    "<font color='red'>**This module is currently under development**</font>\n",
    "\n",
    "## In this tutorial module we explain how we evaluate $\\partial_{t}\\tilde{\\tau}$, terms that depend on the extrinsic curvature, $K_{ij}$, and the energy-momentum tensor $T^{\\mu\\nu}$\n",
    "\n",
    "### Required and recommended citations:\n",
    "\n",
    "* **(Required)** Etienne, Z. B., Paschalidis, V., Haas R., Mösta P., and Shapiro, S. L. IllinoisGRMHD: an open-source, user-friendly GRMHD code for dynamical spacetimes. Class. Quantum Grav. 32 (2015) 175009. ([arxiv:1501.07276](http://arxiv.org/abs/1501.07276)).\n",
    "* **(Required)** Noble, S. C., Gammie, C. F., McKinney, J. C., Del Zanna, L. Primitive Variable Solvers for Conservative General Relativistic Magnetohydrodynamics. Astrophysical Journal, 641, 626 (2006) ([astro-ph/0512420](https://arxiv.org/abs/astro-ph/0512420)).\n",
    "* **(Recommended)** Del Zanna, L., Bucciantini N., Londrillo, P. An efficient shock-capturing central-type scheme for multidimensional relativistic flows - II. Magnetohydrodynamics. A&A 400 (2) 397-413 (2003). DOI: 10.1051/0004-6361:20021641 ([astro-ph/0210618](https://arxiv.org/abs/astro-ph/0210618))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='toc'></a>\n",
    "\n",
    "# Table of Contents\n",
    "$$\\label{toc}$$\n",
    "\n",
    "This module is organized as follows\n",
    "\n",
    "0. [Step 0](#src_dir): **Source directory creation**\n",
    "1. [Step 1](#introduction): **Introduction**\n",
    "1. [Step 2](#compute_tau_rhs_extrinsic_curvature_terms_and_tupmunu__c): **`compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.C`**\n",
    "1. [Step n-1](#code_validation): **Code validation**\n",
    "1. [Step n](#latex_pdf_output): **Output this notebook to $\\LaTeX$-formatted PDF file**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='src_dir'></a>\n",
    "\n",
    "# Step 0: Source directory creation \\[Back to [top](#toc)\\]\n",
    "$$\\label{src_dir}$$\n",
    "\n",
    "We will now use the [cmdline_helper.py NRPy+ module](Tutorial-Tutorial-cmdline_helper.ipynb) to create the source directory within the `IllinoisGRMHD` NRPy+ directory, if it does not exist yet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 0: Creation of the IllinoisGRMHD source directory\n",
    "# Step 0a: Add NRPy's directory to the path\n",
    "# https://stackoverflow.com/questions/16780014/import-file-from-parent-directory\n",
    "import os,sys\n",
    "nrpy_dir_path = os.path.join(\"..\",\"..\")\n",
    "if nrpy_dir_path not in sys.path:\n",
    "    sys.path.append(nrpy_dir_path)\n",
    "\n",
    "# Step 0b: Load up cmdline_helper and create the directory\n",
    "import cmdline_helper as cmd\n",
    "IGM_src_dir_path = os.path.join(\"..\",\"src\")\n",
    "cmd.mkdir(IGM_src_dir_path)\n",
    "\n",
    "# Step 0c: Create the output file path\n",
    "outfile_path__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu__C = os.path.join(IGM_src_dir_path,\"compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.C\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='introduction'></a>\n",
    "\n",
    "# Step 1: Introduction \\[Back to [top](#toc)\\]\n",
    "$$\\label{introduction}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='compute_tau_rhs_extrinsic_curvature_terms_and_tupmunu__c'></a>\n",
    "\n",
    "# Step 2: `compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.C` \\[Back to [top](#toc)\\]\n",
    "$$\\label{compute_tau_rhs_extrinsic_curvature_terms_and_tupmunu__c}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing ../src/compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.C\n"
     ]
    }
   ],
   "source": [
    "%%writefile $outfile_path__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu__C\n",
    "static void compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu\n",
    "(const cGH *cctkGH,const int *cctk_lsh,const int *cctk_nghostzones,CCTK_REAL *dX,CCTK_REAL **metric,gf_and_gz_struct *prims,\n",
    " CCTK_REAL **TUPmunu,eos_struct &eos,CCTK_REAL Gamma_th,\n",
    " CCTK_REAL *gupxy,CCTK_REAL *gupxz,CCTK_REAL *gupyz,\n",
    " CCTK_REAL *kxx,CCTK_REAL *kxy,CCTK_REAL *kxz,CCTK_REAL *kyy,CCTK_REAL *kyz,CCTK_REAL *kzz,\n",
    " CCTK_REAL *tau_rhs) {\n",
    "\n",
    "  // These loop extents must be consistent with add_fluxes_and_source_terms_to_hydro_rhss(), since we use TUPmunu there as well.\n",
    "#pragma omp parallel for\n",
    "  for(int k=cctk_nghostzones[2];k<cctk_lsh[2]-(cctk_nghostzones[2]-1);k++) for(int j=cctk_nghostzones[1];j<cctk_lsh[1]-(cctk_nghostzones[1]-1);j++) for(int i=cctk_nghostzones[0];i<cctk_lsh[0]-(cctk_nghostzones[0]-1);i++) {\n",
    "        int index = CCTK_GFINDEX3D(cctkGH,i,j,k);\n",
    "\n",
    "        // First we pull in needed hydrodynamic and metric variables from memory: PART 1.\n",
    "        // Reading from main memory is a SLOW operation, usually resulting in\n",
    "        //   cache misses, which\n",
    "        //   will waste precious runtime. Note that cache misses will often not\n",
    "        //   show up when using, e.g., gprof. The slowdown due to cache misses\n",
    "        //   can more than double the amount of time in this routine, so instead\n",
    "        //   of reading in variables from main memory multiple times, the below\n",
    "        //   forces us to read in only once, storing in local variables\n",
    "        //   U{p,m}{1,2,3}, METRIC{p,m}{1,2}, U, and METRIC.\n",
    "\n",
    "        CCTK_REAL KxxL = kxx[index];\n",
    "        CCTK_REAL KxyL = kxy[index];\n",
    "        CCTK_REAL KxzL = kxz[index];\n",
    "        CCTK_REAL KyyL = kyy[index];\n",
    "        CCTK_REAL KyzL = kyz[index];\n",
    "        CCTK_REAL KzzL = kzz[index];\n",
    "\n",
    "        //-----------------------------------------------------------------------------\n",
    "        // Compute T^{\\mu \\nu}\n",
    "\n",
    "        CCTK_REAL METRIC[NUMVARS_FOR_METRIC_FACEVALS]; for(int ii=0;ii<NUMVARS_FOR_METRIC_FACEVALS;ii++) METRIC[ii] = metric[ii][index];\n",
    "        CCTK_REAL METRIC_LAP_PSI4[NUMVARS_METRIC_AUX]; SET_LAPSE_PSI4(METRIC_LAP_PSI4,METRIC);\n",
    "\n",
    "        // The \"vector\" U represents the primitive variables: rho, P, vx, vy, vz, Bx, By, and Bz.\n",
    "        CCTK_REAL U[8]; // 8 primitives in the set: {rho_b,P,vx,vy,vz,Bx,By,Bz}\n",
    "        for(int ii=0;ii<8;ii++) U[ii] = prims[ii].gf[index];\n",
    "\n",
    "        struct output_stats stats; stats.failure_checker=0;\n",
    "        CCTK_REAL u0L;\n",
    "        impose_speed_limit_output_u0(METRIC,U,METRIC_LAP_PSI4[PSI4],METRIC_LAP_PSI4[LAPSEINV],stats, u0L);\n",
    "\n",
    "        /***********************************************************/\n",
    "        // Compute b^{\\mu} and b^2\n",
    "        CCTK_REAL ONE_OVER_LAPSE = 1.0/METRIC_LAP_PSI4[LAPSE];\n",
    "        CCTK_REAL ONE_OVER_LAPSE_SQRT_4PI = ONE_OVER_LAPSE*ONE_OVER_SQRT_4PI;\n",
    "        CCTK_REAL u_x_over_u0_psi4,u_y_over_u0_psi4,u_z_over_u0_psi4;\n",
    "        CCTK_REAL smallb[NUMVARS_SMALLB];\n",
    "        compute_smallba_b2_and_u_i_over_u0_psi4(METRIC,METRIC_LAP_PSI4,U,u0L,ONE_OVER_LAPSE_SQRT_4PI,\n",
    "                                                u_x_over_u0_psi4,u_y_over_u0_psi4,u_z_over_u0_psi4,smallb);\n",
    "\n",
    "        /***********************************************************/\n",
    "        // Next compute T^{\\mu \\nu}:\n",
    "        //   First set h, the enthalpy:\n",
    "        CCTK_REAL h=0,  P_cold,eps_cold,dPcold_drho,eps_th,Gamma_cold; /* <- Note that in setting h, we need to define several\n",
    "                                                                        *    other variables, even though they will be unused later\n",
    "                                                                        *    in this function. */\n",
    "        compute_P_cold__eps_cold__dPcold_drho__eps_th__h__Gamma_cold(U,eos,Gamma_th,P_cold,eps_cold,dPcold_drho,eps_th,h,Gamma_cold);\n",
    "\n",
    "        CCTK_REAL Psi6 = METRIC_LAP_PSI4[PSI2]*METRIC_LAP_PSI4[PSI4];\n",
    "        CCTK_REAL Psim4 = 1.0/METRIC_LAP_PSI4[PSI4];\n",
    "\n",
    "        CCTK_REAL rho0_h_plus_b2 = (U[RHOB]*h + smallb[SMALLB2]);\n",
    "        CCTK_REAL P_plus_half_b2 = (U[PRESSURE]+0.5*smallb[SMALLB2]);\n",
    "\n",
    "        CCTK_REAL half_alpha_sqrtgamma = 0.5*METRIC_LAP_PSI4[LAPSE]*Psi6;\n",
    "        CCTK_REAL uUP[4] = { u0L, u0L*U[VX],u0L*U[VY],u0L*U[VZ] };\n",
    "        // If you like, see Eq 2.119 in Numerical Relativity, by Baumgarte & Shapiro:\n",
    "        CCTK_REAL ONE_OVER_LAPSE_SQUARED = SQR(ONE_OVER_LAPSE);\n",
    "        CCTK_REAL g4up[4][4];\n",
    "\n",
    "        g4up[0][0] = -ONE_OVER_LAPSE_SQUARED;\n",
    "        g4up[0][1] = ONE_OVER_LAPSE_SQUARED*METRIC[SHIFTX];\n",
    "        g4up[0][2] = ONE_OVER_LAPSE_SQUARED*METRIC[SHIFTY];\n",
    "        g4up[0][3] = ONE_OVER_LAPSE_SQUARED*METRIC[SHIFTZ];\n",
    "        g4up[1][1] = METRIC[GUPXX]*Psim4 - ONE_OVER_LAPSE_SQUARED*METRIC[SHIFTX]*METRIC[SHIFTX];\n",
    "        // Note that for i!=j, gupij is not stored in METRIC, since we don't need it in face value calculations.\n",
    "        g4up[1][2] = gupxy[index] *Psim4 - ONE_OVER_LAPSE_SQUARED*METRIC[SHIFTX]*METRIC[SHIFTY];\n",
    "        g4up[1][3] = gupxz[index] *Psim4 - ONE_OVER_LAPSE_SQUARED*METRIC[SHIFTX]*METRIC[SHIFTZ];\n",
    "        g4up[2][2] = METRIC[GUPYY]*Psim4 - ONE_OVER_LAPSE_SQUARED*METRIC[SHIFTY]*METRIC[SHIFTY];\n",
    "        g4up[2][3] = gupyz[index] *Psim4 - ONE_OVER_LAPSE_SQUARED*METRIC[SHIFTY]*METRIC[SHIFTZ];\n",
    "        g4up[3][3] = METRIC[GUPZZ]*Psim4 - ONE_OVER_LAPSE_SQUARED*METRIC[SHIFTZ]*METRIC[SHIFTZ];\n",
    "\n",
    "        // Next compute T^{\\mu \\nu}:\n",
    "        // (Eq. 33 in http://arxiv.org/pdf/astro-ph/0503420.pdf):\n",
    "        // T^{mn} = (rho_0 h + b^2) u^m u^n + (P + 0.5 b^2) g^{mn} - b^m b^n, where m and n both run from 0 to 3.\n",
    "        CCTK_REAL TUP[4][4];\n",
    "        for(int ii=0;ii<4;ii++) for(int jj=ii;jj<4;jj++) TUP[ii][jj] = rho0_h_plus_b2*uUP[ii]*uUP[jj] + P_plus_half_b2*g4up[ii][jj] - smallb[SMALLBT+ii]*smallb[SMALLBT+jj];\n",
    "        //-----------------------------------------------------------------------------\n",
    "\n",
    "        //-----------------------------------------------------------------------------\n",
    "        // If we are not in the ghostzones, then compute extrinsic curvature terms for tau_rhs:\n",
    "        //    Without this if() statement, _rhs variables are in general set to nonzero values in ghostzones, which messes up frozen BC's.\n",
    "        //    Also, this if() statement should speed up the computation slightly.\n",
    "        if(k<cctk_lsh[2]-cctk_nghostzones[2] && j<cctk_lsh[1]-cctk_nghostzones[1] && i<cctk_lsh[0]-cctk_nghostzones[0]) {\n",
    "          //  \\alpha \\sqrt{\\gamma} (T^{00} \\beta^i \\beta ^j + 2T^{0i} \\beta^j + T^{ij})*K_{ij}\n",
    "          CCTK_REAL alpha_sqrtgamma = 2.0*half_alpha_sqrtgamma;\n",
    "\n",
    "          //  \\alpha \\sqrt{\\gamma} (T^{00} \\beta^i \\beta ^j + 2T^{0i} \\beta^j + T^{ij})*K_{ij}\n",
    "          CCTK_REAL tau_rhs_extrinsic_curvature_terms = alpha_sqrtgamma*\n",
    "            (\n",
    "             TUP[0][0] * (SQR(METRIC[SHIFTX])*KxxL + SQR(METRIC[SHIFTY])*KyyL + SQR(METRIC[SHIFTZ])*KzzL +\n",
    "                          2.0*(METRIC[SHIFTX]*METRIC[SHIFTY]*KxyL + METRIC[SHIFTX]*METRIC[SHIFTZ]*KxzL + METRIC[SHIFTY]*METRIC[SHIFTZ]*KyzL) ) +\n",
    "             2.0*(TUP[0][1]*METRIC[SHIFTX]*KxxL + TUP[0][2]*METRIC[SHIFTY]*KyyL + TUP[0][3]*METRIC[SHIFTZ]*KzzL +\n",
    "                  (TUP[0][1]*METRIC[SHIFTY] + TUP[0][2]*METRIC[SHIFTX])*KxyL +\n",
    "                  (TUP[0][1]*METRIC[SHIFTZ] + TUP[0][3]*METRIC[SHIFTX])*KxzL +\n",
    "                  (TUP[0][2]*METRIC[SHIFTZ] + TUP[0][3]*METRIC[SHIFTY])*KyzL ) +\n",
    "             TUP[1][1]*KxxL + TUP[2][2]*KyyL + TUP[3][3]*KzzL +\n",
    "             2.0*(TUP[1][2]*KxyL + TUP[1][3]*KxzL + TUP[2][3]*KyzL) );\n",
    "\n",
    "          tau_rhs[index] = tau_rhs_extrinsic_curvature_terms;\n",
    "        }\n",
    "\n",
    "        // Set the T^{\\mu \\nu} gridfunction, since computing T^{\\mu \\nu} is expensive\n",
    "        int counter=0;\n",
    "        for(int ii=0;ii<4;ii++) for(int jj=ii;jj<4;jj++) { TUPmunu[counter][index] = TUP[ii][jj]; counter++; }\n",
    "      }\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='code_validation'></a>\n",
    "\n",
    "# Step n-1: Code validation \\[Back to [top](#toc)\\]\n",
    "$$\\label{code_validation}$$\n",
    "\n",
    "First we download the original `IllinoisGRMHD` source code and then compare it to the source code generated by this tutorial notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation test for compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.C: FAILED!\n",
      "Diff:\n",
      "3c3\n",
      "<  CCTK_REAL **TUPmunu,eos_struct &eos,\n",
      "---\n",
      ">  CCTK_REAL **TUPmunu,eos_struct &eos,CCTK_REAL Gamma_th,\n",
      "20c20\n",
      "<         //   forces us to read in only once, storing in local variables \n",
      "---\n",
      ">         //   forces us to read in only once, storing in local variables\n",
      "43c43\n",
      "<         \n",
      "---\n",
      "> \n",
      "50c50\n",
      "<         compute_smallba_b2_and_u_i_over_u0_psi4(METRIC,METRIC_LAP_PSI4,U,u0L,ONE_OVER_LAPSE_SQRT_4PI,  \n",
      "---\n",
      ">         compute_smallba_b2_and_u_i_over_u0_psi4(METRIC,METRIC_LAP_PSI4,U,u0L,ONE_OVER_LAPSE_SQRT_4PI,\n",
      "56c56\n",
      "<         CCTK_REAL h=0,  P_cold,eps_cold,dPcold_drho,eps_th,gamma_cold; /* <- Note that in setting h, we need to define several \n",
      "---\n",
      ">         CCTK_REAL h=0,  P_cold,eps_cold,dPcold_drho,eps_th,Gamma_cold; /* <- Note that in setting h, we need to define several\n",
      "59c59\n",
      "<         compute_P_cold__eps_cold__dPcold_drho__eps_th__h__gamma_cold(U,eos,P_cold,eps_cold,dPcold_drho,eps_th,h,gamma_cold);\n",
      "---\n",
      ">         compute_P_cold__eps_cold__dPcold_drho__eps_th__h__Gamma_cold(U,eos,Gamma_th,P_cold,eps_cold,dPcold_drho,eps_th,h,Gamma_cold);\n",
      "99c99\n",
      "<       \n",
      "---\n",
      "> \n",
      "103c103\n",
      "<              TUP[0][0] * (SQR(METRIC[SHIFTX])*KxxL + SQR(METRIC[SHIFTY])*KyyL + SQR(METRIC[SHIFTZ])*KzzL + \n",
      "---\n",
      ">              TUP[0][0] * (SQR(METRIC[SHIFTX])*KxxL + SQR(METRIC[SHIFTY])*KyyL + SQR(METRIC[SHIFTZ])*KzzL +\n",
      "105c105\n",
      "<              2.0*(TUP[0][1]*METRIC[SHIFTX]*KxxL + TUP[0][2]*METRIC[SHIFTY]*KyyL + TUP[0][3]*METRIC[SHIFTZ]*KzzL + \n",
      "---\n",
      ">              2.0*(TUP[0][1]*METRIC[SHIFTX]*KxxL + TUP[0][2]*METRIC[SHIFTY]*KyyL + TUP[0][3]*METRIC[SHIFTZ]*KzzL +\n",
      "109c109\n",
      "<              TUP[1][1]*KxxL + TUP[2][2]*KyyL + TUP[3][3]*KzzL + \n",
      "---\n",
      ">              TUP[1][1]*KxxL + TUP[2][2]*KyyL + TUP[3][3]*KzzL +\n",
      "119a120\n",
      "> \n"
     ]
    }
   ],
   "source": [
    "# Verify if the code generated by this tutorial module\n",
    "# matches the original IllinoisGRMHD source code\n",
    "\n",
    "# First download the original IllinoisGRMHD source code\n",
    "import urllib\n",
    "from os import path\n",
    "\n",
    "original_IGM_file_url  = \"https://bitbucket.org/zach_etienne/wvuthorns/raw/5611b2f0b17135538c9d9d17c7da062abe0401b6/IllinoisGRMHD/src/compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.C\"\n",
    "original_IGM_file_name = \"compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu-original.C\"\n",
    "original_IGM_file_path = os.path.join(IGM_src_dir_path,original_IGM_file_name)\n",
    "\n",
    "# Then download the original IllinoisGRMHD source code\n",
    "# We try it here in a couple of ways in an attempt to keep\n",
    "# the code more portable\n",
    "try:\n",
    "    original_IGM_file_code = urllib.request.urlopen(original_IGM_file_url).read().decode(\"utf-8\")\n",
    "    # Write down the file the original IllinoisGRMHD source code\n",
    "    with open(original_IGM_file_path,\"w\") as file:\n",
    "        file.write(original_IGM_file_code)\n",
    "except:\n",
    "    try:\n",
    "        original_IGM_file_code = urllib.urlopen(original_IGM_file_url).read().decode(\"utf-8\")\n",
    "        # Write down the file the original IllinoisGRMHD source code\n",
    "        with open(original_IGM_file_path,\"w\") as file:\n",
    "            file.write(original_IGM_file_code)\n",
    "    except:\n",
    "        # If all else fails, hope wget does the job\n",
    "        !wget -O $original_IGM_file_path $original_IGM_file_url\n",
    "\n",
    "# Perform validation\n",
    "Validation__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu__C  = !diff $original_IGM_file_path $outfile_path__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu__C\n",
    "\n",
    "if Validation__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu__C == []:\n",
    "    # If the validation passes, we do not need to store the original IGM source code file\n",
    "    !rm $original_IGM_file_path\n",
    "    print(\"Validation test for compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.C: PASSED!\")\n",
    "else:\n",
    "    # If the validation fails, we keep the original IGM source code file\n",
    "    print(\"Validation test for compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.C: FAILED!\")\n",
    "    # We also print out the difference between the code generated\n",
    "    # in this tutorial module and the original IGM source code\n",
    "    print(\"Diff:\")\n",
    "    for diff_line in Validation__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu__C:\n",
    "        print(diff_line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='latex_pdf_output'></a>\n",
    "\n",
    "# Step n: 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-IllinoisGRMHD__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.pdf](Tutorial-IllinoisGRMHD__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.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": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "latex_nrpy_style_path = os.path.join(nrpy_dir_path,\"latex_nrpy_style.tplx\")\n",
    "#!jupyter nbconvert --to latex --template $latex_nrpy_style_path --log-level='WARN' Tutorial-IllinoisGRMHD__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.ipynb\n",
    "#!pdflatex -interaction=batchmode Tutorial-IllinoisGRMHD__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.tex\n",
    "#!pdflatex -interaction=batchmode Tutorial-IllinoisGRMHD__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.tex\n",
    "#!pdflatex -interaction=batchmode Tutorial-IllinoisGRMHD__compute_tau_rhs_extrinsic_curvature_terms_and_TUPmunu.tex\n",
    "!rm -f Tut*.out Tut*.aux Tut*.log"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}