def compute_ValenciavU_from_ED_and_BU(ED, BU, gammaDD=None):
# Now, we calculate v^i = ([ijk] E_j B_k) / B^2,
# where [ijk] is the Levi-Civita symbol and B^2 = \gamma_{ij} B^i B^j$ is a trivial dot product in flat space.
# In flat spacetime, use the Minkowski metric; otherwise, use the input metric.
if gammaDD is None:
gammaDD = ixp.zerorank2()
for i in range(3):
gammaDD[i][i] = sp.sympify(1)
unused_gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaDD)
sqrtgammaDET = sp.sqrt(gammaDET)
LeviCivitaTensorUUU = ixp.LeviCivitaTensorUUU_dim3_rank3(sqrtgammaDET)
BD = ixp.zerorank1()
for i in range(3):
for j in range(3):
BD[i] += gammaDD[i][j] * BU[j]
B2 = sp.sympify(0)
for i in range(3):
B2 += BU[i] * BD[i]
ValenciavU = ixp.zerorank1()
for i in range(3):
for j in range(3):
for k in range(3):
ValenciavU[
i] += LeviCivitaTensorUUU[i][j][k] * ED[j] * BD[k] / B2
return ValenciavU
def LambdabarU_lambdaU__exact_gammaDD(gammaDD):
global LambdabarU, lambdaU
if gammaDD == None:
gammaDD = ixp.declarerank2("gammaDD", "sym01")
# \bar{Lambda}^i = \bar{gamma}^{jk}(\bar{Gamma}^i_{jk} - \hat{Gamma}^i_{jk}).
gammabarDD_hDD(gammaDD)
gammabarUU, gammabarDET = ixp.symm_matrix_inverter3x3(gammabarDD)
# First compute Christoffel symbols \bar{Gamma}^i_{jk}, with respect to barred metric:
GammabarUDD = ixp.zerorank3()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
GammabarUDD[i][j][k] += sp.Rational(
1, 2) * gammabarUU[i][l] * (
sp.diff(gammabarDD[l][j], rfm.xx[k]) +
sp.diff(gammabarDD[l][k], rfm.xx[j]) -
sp.diff(gammabarDD[j][k], rfm.xx[l]))
# Next evaluate \bar{Lambda}^i, based on GammabarUDD above and GammahatUDD
# (from the reference metric):
LambdabarU = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
LambdabarU[i] += gammabarUU[j][k] * (GammabarUDD[i][j][k] -
rfm.GammahatUDD[i][j][k])
lambdaU = ixp.zerorank1()
for i in range(DIM):
lambdaU[i] = LambdabarU[i] / rfm.ReU[i]
def gammabar__inverse_and_derivs():
# Step 4.a: Declare as globals all expressions that may be used
# outside this function, declare BSSN gridfunctions
# if not defined already, and set DIM=3.
global gammabarUU, gammabarDD_dD, gammabarDD_dupD, gammabarDD_dDD, GammabarUDD
hDD, aDD, lambdaU, vetU, betU, trK, cf, alpha = declare_BSSN_gridfunctions_if_not_declared_already(
)
DIM = 3
# This function needs gammabarDD, defined in BSSN_basic_tensors()
BSSN_basic_tensors()
# Step 4.a.i: gammabarUU:
gammabarUU, dummydet = ixp.symm_matrix_inverter3x3(gammabarDD)
# Step 4.b.i: gammabarDDdD[i][j][k]
# = \hat{\gamma}_{ij,k} + h_{ij,k} \text{ReDD[i][j]} + h_{ij} \text{ReDDdD[i][j][k]}.
gammabarDD_dD = ixp.zerorank3()
gammabarDD_dupD = ixp.zerorank3()
hDD_dD = ixp.declarerank3("hDD_dD", "sym01")
hDD_dupD = ixp.declarerank3("hDD_dupD", "sym01")
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
gammabarDD_dD[i][j][k] = rfm.ghatDDdD[i][j][k] + \
hDD_dD[i][j][k] * rfm.ReDD[i][j] + hDD[i][j] * rfm.ReDDdD[i][j][k]
# Compute associated upwinded derivative, needed for the \bar{\gamma}_{ij} RHS
gammabarDD_dupD[i][j][k] = rfm.ghatDDdD[i][j][k] + \
hDD_dupD[i][j][k] * rfm.ReDD[i][j] + hDD[i][j] * rfm.ReDDdD[i][j][k]
# Step 4.b.ii: Compute gammabarDD_dDD in terms of the rescaled BSSN quantity hDD
# and its derivatives, as well as the reference metric and rescaling
# matrix, and its derivatives (expression given below):
hDD_dDD = ixp.declarerank4("hDD_dDD", "sym01_sym23")
gammabarDD_dDD = ixp.zerorank4()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
# gammabar_{ij,kl} = gammahat_{ij,kl}
# + h_{ij,kl} ReDD[i][j]
# + h_{ij,k} ReDDdD[i][j][l] + h_{ij,l} ReDDdD[i][j][k]
# + h_{ij} ReDDdDD[i][j][k][l]
gammabarDD_dDD[i][j][k][l] = rfm.ghatDDdDD[i][j][k][l]
gammabarDD_dDD[i][j][k][
l] += hDD_dDD[i][j][k][l] * rfm.ReDD[i][j]
gammabarDD_dDD[i][j][k][l] += hDD_dD[i][j][k] * rfm.ReDDdD[i][j][l] + \
hDD_dD[i][j][l] * rfm.ReDDdD[i][j][k]
gammabarDD_dDD[i][j][k][
l] += hDD[i][j] * rfm.ReDDdDD[i][j][k][l]
# Step 4.b.iii: Define barred Christoffel symbol \bar{\Gamma}^{i}_{kl} = GammabarUDD[i][k][l] (see expression below)
GammabarUDD = ixp.zerorank3()
for i in range(DIM):
for k in range(DIM):
for l in range(DIM):
for m in range(DIM):
# Gammabar^i_{kl} = 1/2 * gammabar^{im} ( gammabar_{mk,l} + gammabar_{ml,k} - gammabar_{kl,m}):
GammabarUDD[i][k][l] += sp.Rational(1, 2) * gammabarUU[i][m] * \
(gammabarDD_dD[m][k][l] + gammabarDD_dD[m][l][k] - gammabarDD_dD[k][l][m])
def trK_AbarDD_aDD(gammaDD, KDD):
global trK, AbarDD, aDD
if gammaDD == None:
gammaDD = ixp.declarerank2("gammaDD", "sym01")
if KDD == None:
KDD = ixp.declarerank2("KDD", "sym01")
if rfm.have_already_called_reference_metric_function == False:
print(
"BSSN.BSSN_in_terms_of_ADM.trK_AbarDD(): Must call reference_metric() first!"
)
sys.exit(1)
# \bar{gamma}_{ij} = (\frac{\bar{gamma}}{gamma})^{1/3}*gamma_{ij}.
gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaDD)
# K = gamma^{ij} K_{ij}, and
# \bar{A}_{ij} &= (\frac{\bar{gamma}}{gamma})^{1/3}*(K_{ij} - \frac{1}{3}*gamma_{ij}*K)
trK = sp.sympify(0)
for i in range(DIM):
for j in range(DIM):
trK += gammaUU[i][j] * KDD[i][j]
AbarDD = ixp.zerorank2()
aDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
AbarDD[i][j] = (rfm.detgammahat / gammaDET)**(sp.Rational(
1, 3)) * (KDD[i][j] - sp.Rational(1, 3) * gammaDD[i][j] * trK)
aDD[i][j] = AbarDD[i][j] / rfm.ReDD[i][j]
def ADM_to_four_metric(gammaDD,
betaU,
alpha,
returng4DD=True,
returng4UU=False):
# The ADM formulation decomposes Einstein's 4D equations into 3+1 dimensional form, with
# the 3 spatial dimensions separated from the 1 temporal dimension. DIM here refers to
# the spatial dimension.
DIM = 3
# Eq 4.47 in [Gourgoulhon](https://arxiv.org/pdf/gr-qc/0703035.pdf):
# g_{tt} = -\alpha^2 + \beta^k \beta_k
# g_{ti} = \beta_i
# g_{ij} = \gamma_{ij}
# Eq. 2.121 in B&S
betaD = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
betaD[i] += gammaDD[i][j] * betaU[j]
# Now compute the beta contraction.
beta2 = sp.sympify(0)
for i in range(DIM):
beta2 += betaU[i] * betaD[i]
g4DD = ixp.zerorank2(DIM=4)
g4DD[0][0] = -alpha**2 + beta2
for i in range(DIM):
g4DD[i + 1][0] = g4DD[0][i + 1] = betaD[i]
for j in range(DIM):
g4DD[i + 1][j + 1] = gammaDD[i][j]
if returng4DD == True and returng4UU == False:
return g4DD
gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaDD)
# Eq. 4.49 in [Gourgoulhon](https://arxiv.org/pdf/gr-qc/0703035.pdf):
# g^{tt} = -1 / alpha^2
# g^{ti} = beta^i / alpha^2
# g^{ij} = gamma^{ij} - beta^i beta^j / alpha^2
g4UU = ixp.zerorank2(DIM=4)
g4UU[0][0] = -1 / alpha**2
for i in range(DIM):
g4UU[i + 1][0] = g4UU[0][i + 1] = betaU[i] / alpha**2
for j in range(DIM):
g4UU[i + 1][j + 1] = gammaUU[i][j] - betaU[i] * betaU[j] / alpha**2
if returng4DD == True and returng4UU == True:
return g4DD, g4UU
if returng4DD == False and returng4UU == True:
return g4UU
print(
"Error: ADM_to_four_metric() called without requesting anything being returned!"
)
exit(1)
def BSSN_or_ADM_ito_g4DD(inputvars,g4DD=None):
# Step 0: Declare output variables as globals, to make interfacing with other modules/functions easier
if inputvars == "ADM":
global gammaDD, betaU, alpha
elif inputvars == "BSSN":
global hDD, cf, vetU, alpha
else:
print("inputvars = " + str(inputvars) + " not supported. Please choose ADM or BSSN.")
sys.exit(1)
# Step 1: declare g4DD as symmetric rank-4 tensor:
if g4DD == None:
g4DD = ixp.declarerank2("g4DD", "sym01", DIM=4)
# Step 2: Compute gammaDD & betaD
betaD = ixp.zerorank1()
gammaDD = ixp.zerorank2()
for i in range(3):
betaD[i] = g4DD[0][i]
for j in range(3):
gammaDD[i][j] = g4DD[i + 1][j + 1]
# Step 3: Compute betaU
# Step 3.a: Compute gammaUU based on provided gammaDD
gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaDD)
# Step 3.b: Use gammaUU to raise betaU
betaU = ixp.zerorank1()
for i in range(3):
for j in range(3):
betaU[i] += gammaUU[i][j] * betaD[j]
# Step 4: Compute alpha = sqrt(beta^2 - g_{00}):
# Step 4.a: Compute beta^2 = beta^k beta_k:
beta_squared = sp.sympify(0)
for k in range(3):
beta_squared += betaU[k] * betaD[k]
# Step 4.b: alpha = sqrt(beta^2 - g_{00}):
if g4DD==None:
alpha = sp.sqrt(sp.simplify(beta_squared) - g4DD[0][0])
else:
alpha = sp.sqrt(beta_squared - g4DD[0][0])
# Step 5: If inputvars == "ADM", we are finished. Return.
if inputvars == "ADM":
return
# Step 6: If inputvars == "BSSN", convert ADM to BSSN
import BSSN.BSSN_in_terms_of_ADM as BitoA
dummyBU = ixp.zerorank1()
BitoA.gammabarDD_hDD(gammaDD)
BitoA.cf_from_gammaDD(gammaDD)
BitoA.betU_vetU(betaU, dummyBU)
hDD = BitoA.hDD
cf = BitoA.cf
vetU = BitoA.vetU
def BSSN_source_terms_for_BSSN_RHSs(custom_T4UU=None):
global sourceterm_trK_rhs, sourceterm_a_rhsDD, sourceterm_lambda_rhsU, sourceterm_Lambdabar_rhsU
# Step 3.a: Call BSSN_source_terms_ito_T4UU to get SDD, SD, S, & rho
if custom_T4UU == "unrescaled BSSN source terms already given":
SDD = ixp.declarerank2("SDD", "sym01")
SD = ixp.declarerank1("SD")
S = sp.symbols("S", real=True)
rho = sp.symbols("rho", real=True)
else:
SDD, SD, S, rho = stress_energy_source_terms_ito_T4UU_and_ADM_or_BSSN_metricvars(
"BSSN", custom_T4UU)
PI = par.Cparameters("REAL", thismodule, ["PI"],
"3.14159265358979323846264338327950288")
alpha = sp.symbols("alpha", real=True)
# Step 3.b: trK_rhs
sourceterm_trK_rhs = 4 * PI * alpha * (rho + S)
# Step 3.c: Abar_rhsDD:
# Step 3.c.i: Compute trace-free part of S_{ij}:
import BSSN.BSSN_quantities as Bq
Bq.BSSN_basic_tensors() # Sets gammabarDD
gammabarUU, dummydet = ixp.symm_matrix_inverter3x3(
Bq.gammabarDD) # Set gammabarUU
tracefree_SDD = ixp.zerorank2()
for i in range(3):
for j in range(3):
tracefree_SDD[i][j] = SDD[i][j]
for i in range(3):
for j in range(3):
for k in range(3):
for m in range(3):
tracefree_SDD[i][j] += -sp.Rational(1, 3) * Bq.gammabarDD[
i][j] * gammabarUU[k][m] * SDD[k][m]
# Step 3.c.ii: Define exp_m4phi = e^{-4 phi}
Bq.phi_and_derivs()
# Step 3.c.iii: Evaluate stress-energy part of AbarDD's RHS
sourceterm_a_rhsDD = ixp.zerorank2()
for i in range(3):
for j in range(3):
Abar_rhsDDij = -8 * PI * alpha * Bq.exp_m4phi * tracefree_SDD[i][j]
sourceterm_a_rhsDD[i][j] = Abar_rhsDDij / rfm.ReDD[i][j]
# Step 3.d: Stress-energy part of Lambdabar_rhsU = stressenergy_Lambdabar_rhsU
sourceterm_Lambdabar_rhsU = ixp.zerorank1()
for i in range(3):
for j in range(3):
sourceterm_Lambdabar_rhsU[
i] += -16 * PI * alpha * gammabarUU[i][j] * SD[j]
sourceterm_lambda_rhsU = ixp.zerorank1()
for i in range(3):
sourceterm_lambda_rhsU[i] = sourceterm_Lambdabar_rhsU[i] / rfm.ReU[i]
def GiRaFFEfood_HO_ID_converter():
gammaDD = ixp.register_gridfunctions_for_single_rank2("AUX",
"gammaDD",
"sym01",
DIM=3)
gammaUU, gammadet = ixp.symm_matrix_inverter3x3(gammaDD)
# Step 5: Build the expression for \tilde{S}_i
global StildeD
StildeD = ixp.zerorank1()
BU = ixp.register_gridfunctions_for_single_rank1(
"AUX", "BU") # Reset so that NRPy will access stored values of BU
###########################################################
#r = rfm.xxSph[0] + KerrSchild_radial_shift # We are setting the data up in Shifted Kerr-Schild coordinates
#theta = rfm.xxSph[1]
#ASphD = ixp.zerorank1()
#ASphD[2] = (r * r * sp.sin(theta)**2)/2
#AD = ixp.zerorank1()
#drrefmetric__dx_0UDmatrix = sp.Matrix([[sp.diff(rfm.xxSph[0],rfm.xx[0]), sp.diff(rfm.xxSph[0],rfm.xx[1]), sp.diff(rfm.xxSph[0],rfm.xx[2])],
# [sp.diff(rfm.xxSph[1],rfm.xx[0]), sp.diff(rfm.xxSph[1],rfm.xx[1]), sp.diff(rfm.xxSph[1],rfm.xx[2])],
# [sp.diff(rfm.xxSph[2],rfm.xx[0]), sp.diff(rfm.xxSph[2],rfm.xx[1]), sp.diff(rfm.xxSph[2],rfm.xx[2])]])
#for i in range(DIM):
# for j in range(DIM):
# AD[i] = drrefmetric__dx_0UDmatrix[(j,i)]*ASphD[j]
#import WeylScal4NRPy.WeylScalars_Cartesian as weyl
#LeviCivitaSymbolDDD = weyl.define_LeviCivitaSymbol_rank3()
#LeviCivitaTensorUUU = ixp.zerorank3()
#for i in range(DIM):
# for j in range(DIM):
# for k in range(DIM):
# LeviCivitaTensorUUU[i][j][k] = LeviCivitaSymbolDDD[i][j][k] / sp.sqrt(gammadet)
## For the initial data, we can analytically take the derivatives of A_i
#ADdD = ixp.zerorank2()
#for i in range(DIM):
# for j in range(DIM):
# ADdD[i][j] = sp.simplify(sp.diff(AD[i],rfm.xxCart[j]))
#BU = ixp.zerorank1()
#for i in range(DIM):
# for j in range(DIM):
# for k in range(DIM):
# BU[i] += LeviCivitaTensorUUU[i][j][k] * ADdD[k][j]
###########################################################
ValenciavU = ixp.register_gridfunctions_for_single_rank1(
"AUX", "ValenciavU"
) # Reset so that NRPy will access stored values of ValenciavU
B2 = sp.sympify(0)
for i in range(DIM):
for j in range(DIM):
B2 += gammaDD[i][j] * BU[i] * BU[j]
for i in range(DIM):
for j in range(DIM):
StildeD[i] += gammaDD[i][j] * (
ValenciavU[j]) * sp.sqrt(gammadet) * B2 / 4 / M_PI
def compute_psi6Phi_rhs_flux_term_operand(gammaDD,sqrtgammaDET,betaU,alpha,AD,psi6Phi):
gammaUU,_gammaDET = ixp.symm_matrix_inverter3x3(gammaDD) # _gammaDET unused.
AU = ixp.zerorank1()
# Raise the index on A in the usual way:
for i in range(3):
for j in range(3):
AU[i] += gammaUU[i][j] * AD[j]
global PhievolParenU
PhievolParenU = ixp.zerorank1(DIM=3)
for j in range(3):
# \alpha\sqrt{\gamma}A^j - \beta^j [\sqrt{\gamma} \Phi]
PhievolParenU[j] += alpha*sqrtgammaDET*AU[j] - betaU[j]*psi6Phi
def Enforce_Detgammabar_Constraint_symb_expressions():
# Set spatial dimension (must be 3 for BSSN)
DIM = 3
# Then we set the coordinate system for the numerical grid
rfm.reference_metric(
) # Create ReU, ReDD needed for rescaling B-L initial data, generating BSSN RHSs, etc.
# We will need the h_{ij} quantities defined within BSSN_RHSs
# below when we enforce the gammahat=gammabar constraint
# Step 1: All barred quantities are defined in terms of BSSN rescaled gridfunctions,
# which we declare here in case they haven't yet been declared elsewhere.
Bq.declare_BSSN_gridfunctions_if_not_declared_already()
hDD = Bq.hDD
Bq.BSSN_basic_tensors()
gammabarDD = Bq.gammabarDD
# First define the Kronecker delta:
KroneckerDeltaDD = ixp.zerorank2()
for i in range(DIM):
KroneckerDeltaDD[i][i] = sp.sympify(1)
# The detgammabar in BSSN_RHSs is set to detgammahat when BSSN_RHSs::detgbarOverdetghat_equals_one=True (default),
# so we manually compute it here:
dummygammabarUU, detgammabar = ixp.symm_matrix_inverter3x3(gammabarDD)
# Next apply the constraint enforcement equation above.
hprimeDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
hprimeDD[i][j] = \
(nrpyAbs(rfm.detgammahat) / detgammabar) ** (sp.Rational(1, 3)) * (KroneckerDeltaDD[i][j] + hDD[i][j]) \
- KroneckerDeltaDD[i][j]
enforce_detg_constraint_symb_expressions = [
lhrh(lhs=gri.gfaccess("in_gfs", "hDD00"), rhs=hprimeDD[0][0]),
lhrh(lhs=gri.gfaccess("in_gfs", "hDD01"), rhs=hprimeDD[0][1]),
lhrh(lhs=gri.gfaccess("in_gfs", "hDD02"), rhs=hprimeDD[0][2]),
lhrh(lhs=gri.gfaccess("in_gfs", "hDD11"), rhs=hprimeDD[1][1]),
lhrh(lhs=gri.gfaccess("in_gfs", "hDD12"), rhs=hprimeDD[1][2]),
lhrh(lhs=gri.gfaccess("in_gfs", "hDD22"), rhs=hprimeDD[2][2])
]
return enforce_detg_constraint_symb_expressions
def gammabarDD_hDD(gammaDD):
global gammabarDD, hDD
if gammaDD == None:
gammaDD = ixp.declarerank2("gammaDD", "sym01")
if rfm.have_already_called_reference_metric_function == False:
print(
"BSSN.BSSN_in_terms_of_ADM.hDD_given_ADM(): Must call reference_metric() first!"
)
sys.exit(1)
# \bar{gamma}_{ij} = (\frac{\bar{gamma}}{gamma})^{1/3}*gamma_{ij}.
gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaDD)
gammabarDD = ixp.zerorank2()
hDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
gammabarDD[i][j] = (rfm.detgammahat / gammaDET)**(sp.Rational(
1, 3)) * gammaDD[i][j]
hDD[i][j] = (gammabarDD[i][j] - rfm.ghatDD[i][j]) / rfm.ReDD[i][j]
def four_metric_to_ADM(g4DD):
# The ADM formulation decomposes Einstein's 4D equations into 3+1 dimensional form, with
# the 3 spatial dimensions separated from the 1 temporal dimension. DIM here refers to
# the spatial dimension.
DIM = 3
# Eq 4.47 in [Gourgoulhon](https://arxiv.org/pdf/gr-qc/0703035.pdf):
# g_{ij} = \gamma_{ij}
gammaDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
gammaDD[i][j] = g4DD[i + 1][j + 1]
# Eq 4.47 in [Gourgoulhon](https://arxiv.org/pdf/gr-qc/0703035.pdf):
# g_{ti} = \beta_i
betaD = ixp.zerorank1()
for i in range(DIM):
betaD[i] = g4DD[i + 1][0]
#Eq. 2.121 in B&S:
# beta^i = gamma^{ij} beta_j
betaU = ixp.zerorank1()
gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaDD)
for i in range(DIM):
for j in range(DIM):
betaU[i] += gammaUU[i][j] * betaD[j]
# Eq 4.47 in [Gourgoulhon](https://arxiv.org/pdf/gr-qc/0703035.pdf):
# g_{tt} = -\alpha^2 + \beta^k \beta_k
# -> alpha = sqrt(beta^2 - g_tt)
# Now compute the beta contraction.
beta2 = sp.sympify(0)
for i in range(DIM):
beta2 += betaU[i] * betaD[i]
alpha = sp.sqrt(beta2 - g4DD[0][0])
return gammaDD, betaU, alpha
def LambdabarU_lambdaU__exact_gammaDD(gammaDD):
global LambdabarU, lambdaU
if gammaDD is None: # Use "is None" instead of "==None", as the former is more correct.
gammaDD = ixp.declarerank2("gammaDD", "sym01")
# \bar{Lambda}^i = \bar{gamma}^{jk}(\bar{Gamma}^i_{jk} - \hat{Gamma}^i_{jk}).
gammabarDD_hDD(gammaDD)
gammabarUU, _gammabarDET = ixp.symm_matrix_inverter3x3(
gammabarDD) # _gammabarDET unused.
# First compute Christoffel symbols \bar{Gamma}^i_{jk}, with respect to barred metric:
GammabarUDD = ixp.zerorank3()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
GammabarUDD[i][j][k] += sp.Rational(
1, 2) * gammabarUU[i][l] * (
sp.diff(gammabarDD[l][j], rfm.xx[k]) +
sp.diff(gammabarDD[l][k], rfm.xx[j]) -
sp.diff(gammabarDD[j][k], rfm.xx[l]))
# Next evaluate \bar{Lambda}^i, based on GammabarUDD above and GammahatUDD
# (from the reference metric):
LambdabarU = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
LambdabarU[i] += gammabarUU[j][k] * (GammabarUDD[i][j][k] -
rfm.GammahatUDD[i][j][k])
for i in range(DIM):
# We evaluate LambdabarU[i] here to ensure proper cancellations. If these cancellations
# are not applied, certain expressions (e.g., lambdaU[0] in StaticTrumpet) will
# cause SymPy's (v1.5+) CSE algorithm to hang
LambdabarU[i] = LambdabarU[i].doit()
lambdaU = ixp.zerorank1()
for i in range(DIM):
lambdaU[i] = LambdabarU[i] / rfm.ReU[i]
def GiRaFFEfood_HO_ID_converter():
gammaDD = ixp.register_gridfunctions_for_single_rank2("AUX",
"gammaDD",
"sym01",
DIM=3)
gammaUU, gammadet = ixp.symm_matrix_inverter3x3(gammaDD)
# Step 5: Build the expression for \tilde{S}_i
global StildeD
StildeD = ixp.zerorank1()
BU = ixp.register_gridfunctions_for_single_rank1(
"AUX", "BU") # Reset so that NRPy will access stored values of BU
ValenciavU = ixp.register_gridfunctions_for_single_rank1(
"AUX", "ValenciavU"
) # Reset so that NRPy will access stored values of ValenciavU
B2 = sp.sympify(0)
for i in range(DIM):
for j in range(DIM):
B2 += gammaDD[i][j] * BU[i] * BU[j]
for i in range(DIM):
StildeD[i] = 0
for j in range(DIM):
StildeD[i] += gammaDD[i][j] * (
ValenciavU[j]) * sp.sqrt(gammadet) * B2 / 4 / M_PI
def ADM_in_terms_of_BSSN():
global gammaDD, gammaDDdD, gammaDDdDD, gammaUU, detgamma, GammaUDD, KDD, KDDdD
# Step 1.c: Given the chosen coordinate system, set up
# corresponding reference metric and needed
# reference metric quantities
# The following function call sets up the reference metric
# and related quantities, including rescaling matrices ReDD,
# ReU, and hatted quantities.
rfm.reference_metric()
# Step 1.d: Set spatial dimension (must be 3 for BSSN, as BSSN is
# a 3+1-dimensional decomposition of the general
# relativistic field equations)
DIM = 3
# Step 1.e: Import all basic (unrescaled) BSSN scalars & tensors
import BSSN.BSSN_quantities as Bq
Bq.BSSN_basic_tensors()
gammabarDD = Bq.gammabarDD
cf = Bq.cf
AbarDD = Bq.AbarDD
trK = Bq.trK
Bq.gammabar__inverse_and_derivs()
gammabarDD_dD = Bq.gammabarDD_dD
gammabarDD_dDD = Bq.gammabarDD_dDD
Bq.AbarUU_AbarUD_trAbar_AbarDD_dD()
AbarDD_dD = Bq.AbarDD_dD
# Step 2: The ADM three-metric gammaDD and its
# derivatives in terms of BSSN quantities.
gammaDD = ixp.zerorank2()
exp4phi = sp.sympify(0)
if par.parval_from_str("EvolvedConformalFactor_cf") == "phi":
exp4phi = sp.exp(4 * cf)
elif par.parval_from_str("EvolvedConformalFactor_cf") == "chi":
exp4phi = (1 / cf)
elif par.parval_from_str("EvolvedConformalFactor_cf") == "W":
exp4phi = (1 / cf ** 2)
else:
print("Error EvolvedConformalFactor_cf type = \"" + par.parval_from_str("EvolvedConformalFactor_cf") + "\" unknown.")
sys.exit(1)
for i in range(DIM):
for j in range(DIM):
gammaDD[i][j] = exp4phi * gammabarDD[i][j]
# Step 2.a: Derivatives of $e^{4\phi}$
phidD = ixp.zerorank1()
phidDD = ixp.zerorank2()
cf_dD = ixp.declarerank1("cf_dD")
cf_dDD = ixp.declarerank2("cf_dDD","sym01")
if par.parval_from_str("EvolvedConformalFactor_cf") == "phi":
for i in range(DIM):
phidD[i] = cf_dD[i]
for j in range(DIM):
phidDD[i][j] = cf_dDD[i][j]
elif par.parval_from_str("EvolvedConformalFactor_cf") == "chi":
for i in range(DIM):
phidD[i] = -sp.Rational(1,4)*exp4phi*cf_dD[i]
for j in range(DIM):
phidDD[i][j] = sp.Rational(1,4)*( exp4phi**2*cf_dD[i]*cf_dD[j] - exp4phi*cf_dDD[i][j] )
elif par.parval_from_str("EvolvedConformalFactor_cf") == "W":
exp2phi = (1 / cf)
for i in range(DIM):
phidD[i] = -sp.Rational(1,2)*exp2phi*cf_dD[i]
for j in range(DIM):
phidDD[i][j] = sp.Rational(1,2)*( exp4phi*cf_dD[i]*cf_dD[j] - exp2phi*cf_dDD[i][j] )
else:
print("Error EvolvedConformalFactor_cf type = \""+par.parval_from_str("EvolvedConformalFactor_cf")+"\" unknown.")
sys.exit(1)
exp4phidD = ixp.zerorank1()
exp4phidDD = ixp.zerorank2()
for i in range(DIM):
exp4phidD[i] = 4*exp4phi*phidD[i]
for j in range(DIM):
exp4phidDD[i][j] = 16*exp4phi*phidD[i]*phidD[j] + 4*exp4phi*phidDD[i][j]
# Step 2.b: Derivatives of gammaDD, the ADM three-metric
gammaDDdD = ixp.zerorank3()
gammaDDdDD = ixp.zerorank4()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
gammaDDdD[i][j][k] = exp4phidD[k] * gammabarDD[i][j] + exp4phi * gammabarDD_dD[i][j][k]
for l in range(DIM):
gammaDDdDD[i][j][k][l] = exp4phidDD[k][l] * gammabarDD[i][j] + \
exp4phidD[k] * gammabarDD_dD[i][j][l] + \
exp4phidD[l] * gammabarDD_dD[i][j][k] + \
exp4phi * gammabarDD_dDD[i][j][k][l]
# Step 2.c: 3-Christoffel symbols associated with ADM 3-metric gammaDD
# Step 2.c.i: First compute the inverse 3-metric gammaUU:
gammaUU, detgamma = ixp.symm_matrix_inverter3x3(gammaDD)
GammaUDD = ixp.zerorank3()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
GammaUDD[i][j][k] += sp.Rational(1,2)*gammaUU[i][l]* \
(gammaDDdD[l][j][k] + gammaDDdD[l][k][j] - gammaDDdD[j][k][l])
# Step 3: Define ADM extrinsic curvature KDD and
# its first spatial derivatives KDDdD
# in terms of BSSN quantities
KDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
KDD[i][j] = exp4phi * AbarDD[i][j] + sp.Rational(1, 3) * gammaDD[i][j] * trK
KDDdD = ixp.zerorank3()
trK_dD = ixp.declarerank1("trK_dD")
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
KDDdD[i][j][k] = exp4phidD[k] * AbarDD[i][j] + exp4phi * AbarDD_dD[i][j][k] + \
sp.Rational(1, 3) * (gammaDDdD[i][j][k] * trK + gammaDD[i][j] * trK_dD[k])
def GiRaFFEfood_HO_Exact_Wald():
# <a id='step2'></a>
#
# ### Step 2: Set the vectors A and E in Spherical coordinates
# $$\label{step2}$$
#
# \[Back to [top](#top)\]
#
# We will first build the fundamental vectors $A_i$ and $E_i$ in spherical coordinates (see [Table 3](https://arxiv.org/pdf/1704.00599.pdf)). Note that we use reference_metric.py to set $r$ and $\theta$ in terms of Cartesian coordinates; this will save us a step later when we convert to Cartesian coordinates. Since $C_0 = 1$,
# \begin{align}
# A_{\phi} &= \frac{1}{2} r^2 \sin^2 \theta \\
# E_{\phi} &= 2 M \left( 1+ \frac {2M}{r} \right)^{-1/2} \sin^2 \theta. \\
# \end{align}
# While we have $E_i$ set as a variable in NRPy+, note that the final C code won't store these values.
# Step 2: Set the vectors A and E in Spherical coordinates
r = rfm.xxSph[
0] + KerrSchild_radial_shift # We are setting the data up in Shifted Kerr-Schild coordinates
theta = rfm.xxSph[1]
IDchoice = par.parval_from_str("IDchoice")
# Initialize all components of A and E in the *spherical basis* to zero
ASphD = ixp.zerorank1()
ESphD = ixp.zerorank1()
if IDchoice is "Exact_Wald":
ASphD[2] = (r * r * sp.sin(theta)**2) / 2
ESphD[2] = 2 * M * sp.sin(theta)**2 / sp.sqrt(1 + 2 * M / r)
else:
print("Error: IDchoice == " + par.parval_from_str("IDchoice") +
" unsupported!")
exit(1)
# <a id='step3'></a>
#
# ### Step 3: Use the Jacobian matrix to transform the vectors to Cartesian coordinates.
# $$\label{step3}$$
#
# \[Back to [top](#top)\]
#
# Now, we will use the coordinate transformation definitions provided by reference_metric.py to build the Jacobian
# $$
# \frac{\partial x_{\rm Sph}^j}{\partial x_{\rm Cart}^i},
# $$
# where $x_{\rm Sph}^j \in \{r,\theta,\phi\}$ and $x_{\rm Cart}^i \in \{x,y,z\}$. We would normally compute its inverse, but since none of the quantities we need to transform have upper indices, it is not necessary. Then, since both $A_i$ and $E_i$ have one lower index, both will need to be multiplied by the Jacobian:
#
# $$
# A_i^{\rm Cart} = A_j^{\rm Sph} \frac{\partial x_{\rm Sph}^j}{\partial x_{\rm Cart}^i},
# $$
# Step 3: Use the Jacobian matrix to transform the vectors to Cartesian coordinates.
drrefmetric__dx_0UDmatrix = sp.Matrix([[
sp.diff(rfm.xxSph[0], rfm.xx[0]),
sp.diff(rfm.xxSph[0], rfm.xx[1]),
sp.diff(rfm.xxSph[0], rfm.xx[2])
],
[
sp.diff(rfm.xxSph[1],
rfm.xx[0]),
sp.diff(rfm.xxSph[1],
rfm.xx[1]),
sp.diff(rfm.xxSph[1], rfm.xx[2])
],
[
sp.diff(rfm.xxSph[2],
rfm.xx[0]),
sp.diff(rfm.xxSph[2],
rfm.xx[1]),
sp.diff(rfm.xxSph[2], rfm.xx[2])
]])
#dx__drrefmetric_0UDmatrix = drrefmetric__dx_0UDmatrix.inv() # We don't actually need this in this case.
global AD
AD = ixp.register_gridfunctions_for_single_rank1("EVOL", "AD")
ED = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
AD[i] = drrefmetric__dx_0UDmatrix[(j, i)] * ASphD[j]
ED[i] = drrefmetric__dx_0UDmatrix[(j, i)] * ESphD[j]
#Step 4: Register the basic spacetime quantities
alpha = gri.register_gridfunctions("AUX", "alpha")
betaU = ixp.register_gridfunctions_for_single_rank1("AUX", "betaU", DIM=3)
gammaDD = ixp.register_gridfunctions_for_single_rank2("AUX",
"gammaDD",
"sym01",
DIM=3)
gammaUU, gammadet = ixp.symm_matrix_inverter3x3(gammaDD)
# <a id='step4'></a>
#
# ### Step 4: Calculate $v^i$ from $A_i$ and $E_i$
# $$\label{step4}$$
#
# \[Back to [top](#top)\]
#
# We will now find the magnetic field using equation 18 in [the original paper](https://arxiv.org/pdf/1704.00599.pdf) $$B^i = \frac{[ijk]}{\sqrt{\gamma}} \partial_j A_k. $$ We will need the metric quantites: the lapse $\alpha$, the shift $\beta^i$, and the three-metric $\gamma_{ij}$. We will also need the Levi-Civita symbol, provided by $\text{WeylScal4NRPy}$.
# Step 4: Calculate v^i from A_i and E_i
# Step 4a: Calculate the magnetic field B^i
# Here, we build the Levi-Civita tensor from the Levi-Civita symbol.
# Here, we build the Levi-Civita tensor from the Levi-Civita symbol.
import WeylScal4NRPy.WeylScalars_Cartesian as weyl
LeviCivitaSymbolDDD = weyl.define_LeviCivitaSymbol_rank3()
LeviCivitaTensorUUU = ixp.zerorank3()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
LeviCivitaTensorUUU[i][j][
k] = LeviCivitaSymbolDDD[i][j][k] / sp.sqrt(gammadet)
# For the initial data, we can analytically take the derivatives of A_i
ADdD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
ADdD[i][j] = sp.simplify(sp.diff(AD[i], rfm.xxCart[j]))
#global BU
BU = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
BU[i] += LeviCivitaTensorUUU[i][j][k] * ADdD[k][j]
# We will now build the initial velocity using equation 152 in [this paper,](https://arxiv.org/pdf/1310.3274v2.pdf) cited in the original $\texttt{GiRaFFE}$ code: $$ v^i = \alpha \frac{\epsilon^{ijk} E_j B_k}{B^2} -\beta^i. $$
# However, our code needs the Valencia 3-velocity while this expression is for the drift velocity. So, we will need to transform it to the Valencia 3-velocity using the rule $\bar{v}^i = \frac{1}{\alpha} \left(v^i +\beta^i \right)$.
# Thus, $$\bar{v}^i = \frac{\epsilon^{ijk} E_j B_k}{B^2}$$
# Step 4b: Calculate B^2 and B_i
# B^2 is an inner product defined in the usual way:
B2 = sp.sympify(0)
for i in range(DIM):
for j in range(DIM):
B2 += gammaDD[i][j] * BU[i] * BU[j]
# Lower the index on B^i
BD = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
BD[i] += gammaDD[i][j] * BU[j]
# Step 4c: Calculate the Valencia 3-velocity
global ValenciavU
ValenciavU = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
ValenciavU[
i] += LeviCivitaTensorUUU[i][j][k] * ED[j] * BD[k] / B2
def ref_metric__hatted_quantities():
# Step 0: Set dimension DIM
DIM = par.parval_from_str("grid::DIM")
global ReU,ReDD,ghatDD,ghatUU,detgammahat
ReU = ixp.zerorank1()
ReDD = ixp.zerorank2()
ghatDD = ixp.zerorank2()
# Step 1: Compute ghatDD (reference metric), ghatUU
# (inverse reference metric), as well as
# rescaling vector ReU & rescaling matrix ReDD
for i in range(DIM):
scalefactor_orthog[i] = sp.sympify(scalefactor_orthog[i])
ghatDD[i][i] = scalefactor_orthog[i]**2
ReU[i] = 1/scalefactor_orthog[i]
for j in range(DIM):
ReDD[i][j] = scalefactor_orthog[i]*scalefactor_orthog[j]
# Step 1b: Compute ghatUU
ghatUU, detgammahat = ixp.symm_matrix_inverter3x3(ghatDD)
# Step 1c: Sanity check: verify that ReDD, ghatDD,
# and ghatUU are all symmetric rank-2:
for i in range(DIM):
for j in range(DIM):
if ReDD[i][j] != ReDD[j][i]:
print("Error: ReDD["+ str(i) + "][" + str(j) + "] != ReDD["+ str(j) + "][" + str(i) + ": " + str(ReDD[i][j]) + "!=" + str(ReDD[j][i]))
exit(1)
if ghatDD[i][j] != ghatDD[j][i]:
print("Error: ghatDD["+ str(i) + "][" + str(j) + "] != ghatDD["+ str(j) + "][" + str(i) + ": " + str(ghatDD[i][j]) + "!=" + str(ghatDD[j][i]))
exit(1)
if ghatUU[i][j] != ghatUU[j][i]:
print("Error: ghatUU["+ str(i) + "][" + str(j) + "] != ghatUU["+ str(j) + "][" + str(i) + ": " + str(ghatUU[i][j]) + "!=" + str(ghatUU[j][i]))
exit(1)
# Step 2: Compute det(ghat) and its 1st & 2nd derivatives
global detgammahatdD,detgammahatdDD
detgammahatdD = ixp.zerorank1(DIM)
detgammahatdDD = ixp.zerorank2(DIM)
for i in range(DIM):
detgammahatdD[i] = (sp.diff(detgammahat, xx[i]))
for j in range(DIM):
detgammahatdDD[i][j] = sp.diff(detgammahatdD[i], xx[j])
# Step 3a: Compute 1st & 2nd derivatives of rescaling vector.
# (E.g., needed in BSSN for betaUdDD computation)
global ReUdD,ReUdDD
ReUdD = ixp.zerorank2(DIM)
ReUdDD = ixp.zerorank3(DIM)
for i in range(DIM):
for j in range(DIM):
ReUdD[i][j] = sp.diff(ReU[i], xx[j])
for k in range(DIM):
ReUdDD[i][j][k] = sp.diff(ReUdD[i][j], xx[k])
# Step 3b: Compute 1st & 2nd derivatives of rescaling matrix.
global ReDDdD,ReDDdDD
ReDDdD = ixp.zerorank3(DIM)
ReDDdDD = ixp.zerorank4(DIM)
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
ReDDdD[i][j][k] = (sp.diff(ReDD[i][j],xx[k]))
for l in range(DIM):
# Simplifying this doesn't appear to help overall NRPy run time.
ReDDdDD[i][j][k][l] = sp.diff(ReDDdD[i][j][k],xx[l])
# Step 3c: Compute 1st & 2nd derivatives of reference metric.
global ghatDDdD,ghatDDdDD
ghatDDdD = ixp.zerorank3(DIM)
ghatDDdDD = ixp.zerorank4(DIM)
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
ghatDDdD[i][j][k] = sp.simplify(sp.diff(ghatDD[i][j],xx[k])) # FIXME: BAD: MUST BE SIMPLIFIED OR ANSWER IS INCORRECT! Must be some bug in sympy...
for l in range(DIM):
ghatDDdDD[i][j][k][l] = (sp.diff(ghatDDdD[i][j][k],xx[l]))
# Step 4a: Compute Christoffel symbols of reference metric.
global GammahatUDD
GammahatUDD = ixp.zerorank3(DIM)
for i in range(DIM):
for k in range(DIM):
for l in range(DIM):
for m in range(DIM):
GammahatUDD[i][k][l] += (sp.Rational(1,2))*ghatUU[i][m]*\
(ghatDDdD[m][k][l] + ghatDDdD[m][l][k] - ghatDDdD[k][l][m])
# Step 4b: Compute derivs of Christoffel symbols of reference metric.
global GammahatUDDdD
GammahatUDDdD = ixp.zerorank4(DIM)
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
GammahatUDDdD[i][j][k][l] = (sp.diff(GammahatUDD[i][j][k],xx[l]))
def WeylScalars_Cartesian():
# We do not need the barred or hatted quantities calculated when using Cartesian coordinates.
# Instead, we declare the PHYSICAL metric and extrinsic curvature as grid functions.
gammaDD = ixp.register_gridfunctions_for_single_rank2(
"EVOL", "gammaDD", "sym01")
kDD = ixp.register_gridfunctions_for_single_rank2("EVOL", "kDD", "sym01")
gammaUU, detgamma = ixp.symm_matrix_inverter3x3(gammaDD)
output_scalars = par.parval_from_str("output_scalars")
global psi4r, psi4i, psi3r, psi3i, psi2r, psi2i, psi1r, psi1i, psi0r, psi0i
# if output_scalars is "all_psis_and_invariants":
# psi4r,psi4i,psi3r,psi3i,psi2r,psi2i,psi1r,psi1i,psi0r,psi0i = sp.symbols("psi4r psi4i\
# psi3r psi3i\
# psi2r psi2i\
# psi1r psi1i\
# psi0r psi0i")
# elif output_scalars is "all_psis":
psi4r,psi4i,psi3r,psi3i,psi2r,psi2i,psi1r,psi1i,psi0r,psi0i = gri.register_gridfunctions("AUX",["psi4r","psi4i",\
"psi3r","psi3i",\
"psi2r","psi2i",\
"psi1r","psi1i",\
"psi0r","psi0i"])
# Step 2a: Set spatial dimension (must be 3 for BSSN)
DIM = 3
par.set_parval_from_str("grid::DIM", DIM)
# Step 2b: Set the coordinate system to Cartesian
x, y, z = gri.register_gridfunctions("AUX", ["x", "y", "z"])
# Step 2c: Set which tetrad is used; at the moment, only one supported option
if par.parval_from_str("WeylScal4NRPy.WeylScalars_Cartesian::TetradChoice"
) == "Approx_QuasiKinnersley":
# Step 3a: Choose 3 orthogonal vectors. Here, we choose one in the azimuthal
# direction, one in the radial direction, and the cross product of the two.
# Eqs 5.6, 5.7 in https://arxiv.org/pdf/gr-qc/0104063.pdf:
# v_1^a &= [-y,x,0] \\
# v_2^a &= [x,y,z] \\
# v_3^a &= {\rm det}(g)^{1/2} g^{ad} \epsilon_{dbc} v_1^b v_2^c,
v1U = ixp.zerorank1()
v2U = ixp.zerorank1()
v3U = ixp.zerorank1()
v1U[0] = -y
v1U[1] = x
v1U[2] = sp.sympify(0)
v2U[0] = x
v2U[1] = y
v2U[2] = z
LeviCivitaSymbol_rank3 = define_LeviCivitaSymbol_rank3()
for a in range(DIM):
for b in range(DIM):
for c in range(DIM):
for d in range(DIM):
v3U[a] += sp.sqrt(
detgamma) * gammaUU[a][d] * LeviCivitaSymbol_rank3[
d][b][c] * v1U[b] * v2U[c]
# Step 3b: Gram-Schmidt orthonormalization of the vectors.
# The w_i^a vectors here are used to temporarily hold values on the way to the final vectors e_i^a
# e_1^a &= \frac{v_1^a}{\omega_{11}} \\
# e_2^a &= \frac{v_2^a - \omega_{12} e_1^a}{\omega_{22}} \\
# e_3^a &= \frac{v_3^a - \omega_{13} e_1^a - \omega_{23} e_2^a}{\omega_{33}}, \\
# Normalize the first vector
w1U = ixp.zerorank1()
for a in range(DIM):
w1U[a] = v1U[a]
omega11 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega11 += w1U[a] * w1U[b] * gammaDD[a][b]
e1U = ixp.zerorank1()
for a in range(DIM):
e1U[a] = w1U[a] / sp.sqrt(omega11)
# Subtract off the portion of the first vector along the second, then normalize
omega12 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega12 += e1U[a] * v2U[b] * gammaDD[a][b]
w2U = ixp.zerorank1()
for a in range(DIM):
w2U[a] = v2U[a] - omega12 * e1U[a]
omega22 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega22 += w2U[a] * w2U[b] * gammaDD[a][b]
e2U = ixp.zerorank1()
for a in range(DIM):
e2U[a] = w2U[a] / sp.sqrt(omega22)
# Subtract off the portion of the first and second vectors along the third, then normalize
omega13 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega13 += e1U[a] * v3U[b] * gammaDD[a][b]
omega23 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega23 += e2U[a] * v3U[b] * gammaDD[a][b]
w3U = ixp.zerorank1()
for a in range(DIM):
w3U[a] = v3U[a] - omega13 * e1U[a] - omega23 * e2U[a]
omega33 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega33 += w3U[a] * w3U[b] * gammaDD[a][b]
e3U = ixp.zerorank1()
for a in range(DIM):
e3U[a] = w3U[a] / sp.sqrt(omega33)
# Step 3c: Construct the tetrad itself.
# Eqs. 5.6:
# l^a &= \frac{1}{\sqrt{2}} e_2^a \\
# n^a &= -\frac{1}{\sqrt{2}} e_2^a \\
# m^a &= \frac{1}{\sqrt{2}} (e_3^a + i e_1^a) \\
# \overset{*}{m}{}^a &= \frac{1}{\sqrt{2}} (e_3^a - i e_1^a)
isqrt2 = 1 / sp.sqrt(2)
ltetU = ixp.zerorank1()
ntetU = ixp.zerorank1()
#mtetU = ixp.zerorank1()
#mtetccU = ixp.zerorank1()
remtetU = ixp.zerorank1(
) # SymPy does not like trying to take the real/imaginary parts of such a
immtetU = ixp.zerorank1(
) # complicated expression as the Weyl scalars, so we will do it ourselves.
for i in range(DIM):
ltetU[i] = isqrt2 * e2U[i]
ntetU[i] = -isqrt2 * e2U[i]
remtetU[i] = isqrt2 * e3U[i]
immtetU[i] = isqrt2 * e1U[i]
nn = isqrt2
else:
print("Error: TetradChoice == " + par.parval_from_str("TetradChoice") +
" unsupported!")
exit(1)
gammaDD_dD = ixp.declarerank3("gammaDD_dD", "sym01")
# Define the Christoffel symbols
GammaUDD = ixp.zerorank3(DIM)
for i in range(DIM):
for k in range(DIM):
for l in range(DIM):
for m in range(DIM):
GammaUDD[i][k][l] += (sp.Rational(1,2))*gammaUU[i][m]*\
(gammaDD_dD[m][k][l] + gammaDD_dD[m][l][k] - gammaDD_dD[k][l][m])
# Step 4b: Declare and construct the Riemann curvature tensor:
# R_{abcd} = \frac{1}{2} (\gamma_{ad,cb}+\gamma_{bc,da}-\gamma_{ac,bd}-\gamma_{bd,ac})
# + \gamma_{je} \Gamma^{j}_{bc}\Gamma^{e}_{ad} - \gamma_{je} \Gamma^{j}_{bd} \Gamma^{e}_{ac}
gammaDD_dDD = ixp.declarerank4("gammaDD_dDD", "sym01_sym23")
RiemannDDDD = ixp.zerorank4()
for a in range(DIM):
for b in range(DIM):
for c in range(DIM):
for d in range(DIM):
RiemannDDDD[a][b][c][d] = (gammaDD_dDD[a][d][c][b] + \
gammaDD_dDD[b][c][d][a] - \
gammaDD_dDD[a][c][b][d] - \
gammaDD_dDD[b][d][a][c]) / 2
for e in range(DIM):
for j in range(DIM):
RiemannDDDD[a][b][c][d] += gammaDD[j][e] * GammaUDD[j][b][c] * GammaUDD[e][a][d] - \
gammaDD[j][e] * GammaUDD[j][b][d] * GammaUDD[e][a][c]
# Step 4c: We also need the extrinsic curvature tensor $K_{ij}$.
# In Cartesian coordinates, we already made the components gridfunctions.
# We will, however, need to calculate the trace of K seperately:
trK = sp.sympify(0)
for i in range(DIM):
for j in range(DIM):
trK += gammaUU[i][j] * kDD[i][j]
# Step 5: Build the formula for \psi_4.
# Gauss equation: involving the Riemann tensor and extrinsic curvature.
# GaussDDDD[i][j][k][l] =& R_{ijkl} + 2K_{i[k}K_{l]j}
GaussDDDD = ixp.zerorank4()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
GaussDDDD[i][j][k][l] = RiemannDDDD[i][j][k][
l] + kDD[i][k] * kDD[l][j] - kDD[i][l] * kDD[k][j]
# Codazzi equation: involving partial derivatives of the extrinsic curvature.
# We will first need to declare derivatives of kDD
# CodazziDDD[j][k][l] =& -2 (K_{j[k,l]} + \Gamma^p_{j[k} K_{l]p})
kDD_dD = ixp.declarerank3("kDD_dD", "sym01")
CodazziDDD = ixp.zerorank3()
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
CodazziDDD[j][k][l] = kDD_dD[j][l][k] - kDD_dD[j][k][l]
for p in range(DIM):
CodazziDDD[j][k][l] += GammaUDD[p][j][l] * kDD[k][
p] - GammaUDD[p][j][k] * kDD[l][p]
# Another piece. While not associated with any particular equation,
# this is still useful for organizational purposes.
# RojoDD[j][l]} = & R_{jl} - K_{jp} K^p_l + KK_{jl} \\
# = & \gamma^{pd} R_{jpld} - K_{jp} K^p_l + KK_{jl}
RojoDD = ixp.zerorank2()
for j in range(DIM):
for l in range(DIM):
RojoDD[j][l] = trK * kDD[j][l]
for p in range(DIM):
for d in range(DIM):
RojoDD[j][l] += gammaUU[p][d] * RiemannDDDD[j][p][l][
d] - kDD[j][p] * gammaUU[p][d] * kDD[d][l]
# Now we can calculate $\psi_4$ itself! We assume l^0 = n^0 = \frac{1}{\sqrt{2}}
# and m^0 = \overset{*}{m}{}^0 = 0 to simplify these equations.
# We calculate the Weyl scalars as defined in https://arxiv.org/abs/gr-qc/0104063
# In terms of the above-defined quantites, the psis are defined as:
# \psi_4 =&\ (\text{GaussDDDD[i][j][k][l]}) n^i \overset{*}{m}{}^j n^k \overset{*}{m}{}^l \\
# &+2 (\text{CodazziDDD[j][k][l]}) n^{0} \overset{*}{m}{}^{j} n^k \overset{*}{m}{}^l \\
# &+ (\text{RojoDD[j][l]}) n^{0} \overset{*}{m}{}^{j} n^{0} \overset{*}{m}{}^{l}.
# \psi_3 =&\ (\text{GaussDDDD[i][j][k][l]}) l^i n^j \overset{*}{m}{}^k n^l \\
# &+ (\text{CodazziDDD[j][k][l]}) (l^{0} n^{j} \overset{*}{m}{}^k n^l - l^{j} n^{0} \overset{*}{m}{}^k n^l - l^k n^j\overset{*}{m}{}^l n^0) \\
# &- (\text{RojoDD[j][l]}) l^{0} n^{j} \overset{*}{m}{}^l n^0 - l^{j} n^{0} \overset{*}{m}{}^l n^0 \\
# \psi_2 =&\ (\text{GaussDDDD[i][j][k][l]}) l^i m^j \overset{*}{m}{}^k n^l \\
# &+ (\text{CodazziDDD[j][k][l]}) (l^{0} m^{j} \overset{*}{m}{}^k n^l - l^{j} m^{0} \overset{*}{m}{}^k n^l - l^k m^l \overset{*}{m}{}^l n^0) \\
# &- (\text{RojoDD[j][l]}) l^0 m^j \overset{*}{m}{}^l n^0 \\
# \psi_1 =&\ (\text{GaussDDDD[i][j][k][l]}) n^i l^j m^k l^l \\
# &+ (\text{CodazziDDD[j][k][l]}) (n^{0} l^{j} m^k l^l - n^{j} l^{0} m^k l^l - n^k l^l m^j l^0) \\
# &- (\text{RojoDD[j][l]}) (n^{0} l^{j} m^l l^0 - n^{j} l^{0} m^l l^0) \\
# \psi_0 =&\ (\text{GaussDDDD[i][j][k][l]}) l^i m^j l^k m^l \\
# &+2 (\text{CodazziDDD[j][k][l]}) (l^0 m^j l^k m^l + l^k m^l l^0 m^j) \\
# &+ (\text{RojoDD[j][l]}) l^0 m^j l^0 m^j. \\
psi4r = sp.sympify(0)
psi4i = sp.sympify(0)
psi3r = sp.sympify(0)
psi3i = sp.sympify(0)
psi2r = sp.sympify(0)
psi2i = sp.sympify(0)
psi1r = sp.sympify(0)
psi1i = sp.sympify(0)
psi0r = sp.sympify(0)
psi0i = sp.sympify(0)
for l in range(DIM):
for j in range(DIM):
psi4r += RojoDD[j][l] * nn * nn * (remtetU[j] * remtetU[l] -
immtetU[j] * immtetU[l])
psi4i += RojoDD[j][l] * nn * nn * (-remtetU[j] * immtetU[l] -
immtetU[j] * remtetU[l])
psi3r += -RojoDD[j][l] * nn * nn * (ntetU[j] -
ltetU[j]) * remtetU[l]
psi3i += RojoDD[j][l] * nn * nn * (ntetU[j] -
ltetU[j]) * immtetU[l]
psi2r += -RojoDD[j][l] * nn * nn * (remtetU[l] * remtetU[j] +
immtetU[j] * immtetU[l])
psi2i += -RojoDD[j][l] * nn * nn * (immtetU[l] * remtetU[j] -
remtetU[j] * immtetU[l])
psi1r += RojoDD[j][l] * nn * nn * (ntetU[j] * remtetU[l] -
ltetU[j] * remtetU[l])
psi1i += RojoDD[j][l] * nn * nn * (ntetU[j] * immtetU[l] -
ltetU[j] * immtetU[l])
psi0r += RojoDD[j][l] * nn * nn * (remtetU[j] * remtetU[l] -
immtetU[j] * immtetU[l])
psi0i += RojoDD[j][l] * nn * nn * (remtetU[j] * immtetU[l] +
immtetU[j] * remtetU[l])
for l in range(DIM):
for j in range(DIM):
for k in range(DIM):
psi4r += 2 * CodazziDDD[j][k][l] * ntetU[k] * nn * (
remtetU[j] * remtetU[l] - immtetU[j] * immtetU[l])
psi4i += 2 * CodazziDDD[j][k][l] * ntetU[k] * nn * (
-remtetU[j] * immtetU[l] - immtetU[j] * remtetU[l])
psi3r += 1 * CodazziDDD[j][k][l] * nn * (
(ntetU[j] - ltetU[j]) * remtetU[k] * ntetU[l] -
remtetU[j] * ltetU[k] * ntetU[l])
psi3i += -1 * CodazziDDD[j][k][l] * nn * (
(ntetU[j] - ltetU[j]) * immtetU[k] * ntetU[l] -
immtetU[j] * ltetU[k] * ntetU[l])
psi2r += 1 * CodazziDDD[j][k][l] * nn * (
ntetU[l] *
(remtetU[j] * remtetU[k] + immtetU[j] * immtetU[k]) -
ltetU[k] *
(remtetU[j] * remtetU[l] + immtetU[j] * immtetU[l]))
psi2i += 1 * CodazziDDD[j][k][l] * nn * (
ntetU[l] *
(immtetU[j] * remtetU[k] - remtetU[j] * immtetU[k]) -
ltetU[k] *
(remtetU[j] * immtetU[l] - immtetU[j] * remtetU[l]))
psi1r += 1 * CodazziDDD[j][k][l] * nn * (
ltetU[j] * remtetU[k] * ltetU[l] - remtetU[j] * ntetU[k] *
ltetU[l] - ntetU[j] * remtetU[k] * ltetU[l])
psi1i += 1 * CodazziDDD[j][k][l] * nn * (
ltetU[j] * immtetU[k] * ltetU[l] - immtetU[j] * ntetU[k] *
ltetU[l] - ntetU[j] * immtetU[k] * ltetU[l])
psi0r += 2 * CodazziDDD[j][k][l] * nn * ltetU[k] * (
remtetU[j] * remtetU[l] - immtetU[j] * immtetU[l])
psi0i += 2 * CodazziDDD[j][k][l] * nn * ltetU[k] * (
remtetU[j] * immtetU[l] + immtetU[j] * remtetU[l])
for l in range(DIM):
for j in range(DIM):
for k in range(DIM):
for i in range(DIM):
psi4r += GaussDDDD[i][j][k][l] * ntetU[i] * ntetU[k] * (
remtetU[j] * remtetU[l] - immtetU[j] * immtetU[l])
psi4i += GaussDDDD[i][j][k][l] * ntetU[i] * ntetU[k] * (
-remtetU[j] * immtetU[l] - immtetU[j] * remtetU[l])
psi3r += GaussDDDD[i][j][k][l] * ltetU[i] * ntetU[
j] * remtetU[k] * ntetU[l]
psi3i += -GaussDDDD[i][j][k][l] * ltetU[i] * ntetU[
j] * immtetU[k] * ntetU[l]
psi2r += GaussDDDD[i][j][k][l] * ltetU[i] * ntetU[l] * (
remtetU[j] * remtetU[k] + immtetU[j] * immtetU[k])
psi2i += GaussDDDD[i][j][k][l] * ltetU[i] * ntetU[l] * (
immtetU[j] * remtetU[k] - remtetU[j] * immtetU[k])
psi1r += GaussDDDD[i][j][k][l] * ntetU[i] * ltetU[
j] * remtetU[k] * ltetU[l]
psi1i += GaussDDDD[i][j][k][l] * ntetU[i] * ltetU[
j] * immtetU[k] * ltetU[l]
psi0r += GaussDDDD[i][j][k][l] * ltetU[i] * ltetU[k] * (
remtetU[j] * remtetU[l] - immtetU[j] * immtetU[l])
psi0i += GaussDDDD[i][j][k][l] * ltetU[i] * ltetU[k] * (
remtetU[j] * immtetU[l] + immtetU[j] * remtetU[l])
def GiRaFFE_Higher_Order_v2():
#Step 1.0: Set the spatial dimension parameter to 3.
par.set_parval_from_str("grid::DIM", 3)
DIM = par.parval_from_str("grid::DIM")
# Step 1.1: Set the finite differencing order to 4.
#par.set_parval_from_str("finite_difference::FD_CENTDERIVS_ORDER", 4)
thismodule = "GiRaFFE_NRPy"
# M_PI will allow the C code to substitute the correct value
M_PI = par.Cparameters("#define",thismodule,"M_PI","")
# ADMBase defines the 4-metric in terms of the 3+1 spacetime metric quantities gamma_{ij}, beta^i, and alpha
gammaDD = ixp.register_gridfunctions_for_single_rank2("AUX","gammaDD", "sym01",DIM=3)
betaU = ixp.register_gridfunctions_for_single_rank1("AUX","betaU",DIM=3)
alpha = gri.register_gridfunctions("AUX","alpha")
# GiRaFFE uses the Valencia 3-velocity and A_i, which are defined in the initial data module(GiRaFFEfood)
ValenciavU = ixp.register_gridfunctions_for_single_rank1("AUX","ValenciavU",DIM=3)
AD = ixp.register_gridfunctions_for_single_rank1("EVOL","AD",DIM=3)
# B^i must be computed at each timestep within GiRaFFE so that the Valencia 3-velocity can be evaluated
BU = ixp.register_gridfunctions_for_single_rank1("AUX","BU",DIM=3)
# <a id='step3'></a>
#
# ## Step 1.2: Build the four metric $g_{\mu\nu}$, its inverse $g^{\mu\nu}$ and spatial derivatives $g_{\mu\nu,i}$ from ADM 3+1 quantities $\gamma_{ij}$, $\beta^i$, and $\alpha$ \[Back to [top](#top)\]
#
# Notice that the time evolution equation for $\tilde{S}_i$
# $$
# \partial_t \tilde{S}_i = - \partial_j \left( \alpha \sqrt{\gamma} T^j_{{\rm EM} i} \right) + \frac{1}{2} \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu}
# $$
# contains $\partial_i g_{\mu \nu} = g_{\mu\nu,i}$. We will now focus on evaluating this term.
#
# The four-metric $g_{\mu\nu}$ is related to the three-metric $\gamma_{ij}$, index-lowered shift $\beta_i$, and lapse $\alpha$ by
# $$
# g_{\mu\nu} = \begin{pmatrix}
# -\alpha^2 + \beta^k \beta_k & \beta_j \\
# \beta_i & \gamma_{ij}
# \end{pmatrix}.
# $$
# This tensor and its inverse have already been built by the u0_smallb_Poynting__Cartesian.py module ([documented here](Tutorial-u0_smallb_Poynting-Cartesian.ipynb)), so we can simply load the module and import the variables.
# $$\label{step3}$$
# Step 1.2: import u0_smallb_Poynting__Cartesian.py to set
# the four metric and its inverse. This module also sets b^2 and u^0.
import u0_smallb_Poynting__Cartesian.u0_smallb_Poynting__Cartesian as u0b
u0b.compute_u0_smallb_Poynting__Cartesian(gammaDD,betaU,alpha,ValenciavU,BU)
betaD = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
betaD[i] += gammaDD[i][j] * betaU[j]
# Error check: fixed = to +=
# We will now pull in the four metric and its inverse.
import BSSN.ADMBSSN_tofrom_4metric as AB4m # NRPy+: ADM/BSSN <-> 4-metric conversions
AB4m.g4DD_ito_BSSN_or_ADM("ADM")
g4DD = AB4m.g4DD
AB4m.g4UU_ito_BSSN_or_ADM("ADM")
g4UU = AB4m.g4UU
# Next we compute spatial derivatives of the metric, $\partial_i g_{\mu\nu} = g_{\mu\nu,i}$, written in terms of the three-metric, shift, and lapse. Simply taking the derivative of the expression for $g_{\mu\nu}$ above, we find
# $$
# g_{\mu\nu,l} = \begin{pmatrix}
# -2\alpha \alpha_{,l} + \beta^k_{\ ,l} \beta_k + \beta^k \beta_{k,l} & \beta_{j,l} \\
# \beta_{i,l} & \gamma_{ij,l}
# \end{pmatrix}.
# $$
#
# Notice the derivatives of the shift vector with its indexed lowered, $\beta_{i,j} = \partial_j \beta_i$. This can be easily computed in terms of the given ADMBase quantities $\beta^i$ and $\gamma_{ij}$ via:
# \begin{align}
# \beta_{i,j} &= \partial_j \beta_i \\
# &= \partial_j (\gamma_{ik} \beta^k) \\
# &= \gamma_{ik} \partial_j\beta^k + \beta^k \partial_j \gamma_{ik} \\
# \beta_{i,j} &= \gamma_{ik} \beta^k_{\ ,j} + \beta^k \gamma_{ik,j}.
# \end{align}
#
# Since this expression mixes Greek and Latin indices, we will declare this as a 4 dimensional quantity, but only set the three spatial components of its last index (that is, leaving $l=0$ unset).
#
# So, we will first set
# $$ g_{00,l} = \underbrace{-2\alpha \alpha_{,l}}_{\rm Term\ 1} + \underbrace{\beta^k_{\ ,l} \beta_k}_{\rm Term\ 2} + \underbrace{\beta^k \beta_{k,l}}_{\rm Term\ 3} $$
# Step 1.2, cont'd: Build spatial derivatives of the four metric
# Step 1.2.a: Declare derivatives of grid functions. These will be handled by FD_outputC
alpha_dD = ixp.declarerank1("alpha_dD")
betaU_dD = ixp.declarerank2("betaU_dD","nosym")
gammaDD_dD = ixp.declarerank3("gammaDD_dD","sym01")
# Step 1.2.b: These derivatives will be constructed analytically.
betaDdD = ixp.zerorank2()
g4DDdD = ixp.zerorank3(DIM=4)
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
# \gamma_{ik} \beta^k_{,j} + \beta^k \gamma_{ik,j}
betaDdD[i][j] += gammaDD[i][k] * betaU_dD[k][j] + betaU[k] * gammaDD_dD[i][k][j]
#Error check: changed = to += above
# Step 1.2.c: Set the 00 components
# Step 1.2.c.i: Term 1: -2\alpha \alpha_{,l}
for l in range(DIM):
g4DDdD[0][0][l+1] = -2*alpha*alpha_dD[l]
# Step 1.2.c.ii: Term 2: \beta^k_{\ ,l} \beta_k
for l in range(DIM):
for k in range(DIM):
g4DDdD[0][0][l+1] += betaU_dD[k][l] * betaD[k]
# Step 1.2.c.iii: Term 3: \beta^k \beta_{k,l}
for l in range(DIM):
for k in range(DIM):
g4DDdD[0][0][l+1] += betaU[k] * betaDdD[k][l]
# Now we will contruct the other components of $g_{\mu\nu,l}$. We will first construct
# $$ g_{i0,l} = g_{0i,l} = \beta_{i,l}, $$
# then
# $$ g_{ij,l} = \gamma_{ij,l} $$
# Step 1.2.d: Set the i0 and 0j components
for l in range(DIM):
for i in range(DIM):
# \beta_{i,l}
g4DDdD[i+1][0][l+1] = g4DDdD[0][i+1][l+1] = betaDdD[i][l]
#Step 1.2.e: Set the ij components
for l in range(DIM):
for i in range(DIM):
for j in range(DIM):
# \gamma_{ij,l}
g4DDdD[i+1][j+1][l+1] = gammaDD_dD[i][j][l]
# <a id='step4'></a>
#
# # $T^{\mu\nu}_{\rm EM}$ and its derivatives
#
# Now that the metric and its derivatives are out of the way, let's return to the evolution equation for $\tilde{S}_i$,
# $$
# \partial_t \tilde{S}_i = - \partial_j \left( \alpha \sqrt{\gamma} T^j_{{\rm EM} i} \right) + \frac{1}{2} \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu}.
# $$
# We turn our focus now to $T^j_{{\rm EM} i}$ and its derivatives. To this end, we start by computing $T^{\mu \nu}_{\rm EM}$ (from eq. 27 of [Paschalidis & Shapiro's paper on their GRFFE code](https://arxiv.org/pdf/1310.3274.pdf)):
#
# $$\boxed{T^{\mu \nu}_{\rm EM} = b^2 u^{\mu} u^{\nu} + \frac{b^2}{2} g^{\mu \nu} - b^{\mu} b^{\nu}.}$$
#
# Notice that $T^{\mu\nu}_{\rm EM}$ is written in terms of
#
# * $b^\mu$, the 4-component magnetic field vector, related to the comoving magnetic field vector $B^i_{(u)}$
# * $u^\mu$, the 4-velocity
# * $g^{\mu \nu}$, the inverse 4-metric
#
# However, $\texttt{GiRaFFE}$ has access to only the following quantities, requiring in the following sections that we write the above quantities in terms of the following ones:
#
# * $\gamma_{ij}$, the 3-metric
# * $\alpha$, the lapse
# * $\beta^i$, the shift
# * $A_i$, the vector potential
# * $B^i$, the magnetic field (we assume only in the grid interior, not the ghost zones)
# * $\left[\sqrt{\gamma}\Phi\right]$, the zero-component of the vector potential $A_\mu$, times the square root of the determinant of the 3-metric
# * $v_{(n)}^i$, the Valencia 3-velocity
# * $u^0$, the zero-component of the 4-velocity
#
# ## Step 2.0: $u^i$ and $b^i$ and related quantities \[Back to [top](#top)\]
#
# We begin by importing what we can from u0_smallb_Poynting__Cartesian.py. We will need the four-velocity $u^\mu$, which is related to the Valencia 3-velocity $v^i_{(n)}$ used directly by $\texttt{GiRaFFE}$ (see also [Duez, et al, eqs. 53 and 56](https://arxiv.org/pdf/astro-ph/0503420.pdf))
# \begin{align}
# u^i &= u^0 (\alpha v^i_{(n)} - \beta^i), \\
# u_j &= \alpha u^0 \gamma_{ij} v^i_{(n)},
# \end{align}
# where $v^i_{(n)}$ is the Valencia three-velocity. These have already been constructed in terms of the Valencia 3-velocity and other 3+1 ADM quantities by the u0_smallb_Poynting__Cartesian.py module, so we can simply import these variables:
# $$\label{step4}$$
# Step 2.0: u^i, b^i, and related quantities
# Step 2.0.a: import the four-velocity, as written in terms of the Valencia 3-velocity
uD = ixp.zerorank1()
uU = ixp.zerorank1()
u4upperZero = gri.register_gridfunctions("AUX","u4upperZero")
for i in range(DIM):
uD[i] = u0b.uD[i].subs(u0b.u0,u4upperZero)
uU[i] = u0b.uU[i].subs(u0b.u0,u4upperZero)
# We also need the magnetic field 4-vector $b^{\mu}$, which is related to the magnetic field by [eqs. 23, 24, and 31 in Duez, et al](https://arxiv.org/pdf/astro-ph/0503420.pdf):
# \begin{align}
# b^0 &= \frac{1}{\sqrt{4\pi}} B^0_{\rm (u)} = \frac{u_j B^j}{\sqrt{4\pi}\alpha}, \\
# b^i &= \frac{1}{\sqrt{4\pi}} B^i_{\rm (u)} = \frac{B^i + (u_j B^j) u^i}{\sqrt{4\pi}\alpha u^0}, \\
# \end{align}
# where $B^i$ is the variable tracked by the HydroBase thorn in the Einstein Toolkit. Again, these have already been built by the u0_smallb_Poynting__Cartesian.py module, so we can simply import the variables.
# Step 2.0.b: import the small b terms
smallb4U = ixp.zerorank1(DIM=4)
smallb4D = ixp.zerorank1(DIM=4)
for mu in range(4):
smallb4U[mu] = u0b.smallb4U[mu].subs(u0b.u0,u4upperZero)
smallb4D[mu] = u0b.smallb4D[mu].subs(u0b.u0,u4upperZero)
smallb2 = u0b.smallb2etk.subs(u0b.u0,u4upperZero)
# <a id='step5'></a>
#
# ## Step 2.1: Construct all components of the electromagnetic stress-energy tensor $T^{\mu \nu}_{\rm EM}$ \[Back to [top](#top)\]
#
# We now have all the pieces to calculate the stress-energy tensor,
# $$T^{\mu \nu}_{\rm EM} = \underbrace{b^2 u^{\mu} u^{\nu}}_{\rm Term\ 1} +
# \underbrace{\frac{b^2}{2} g^{\mu \nu}}_{\rm Term\ 2}
# - \underbrace{b^{\mu} b^{\nu}}_{\rm Term\ 3}.$$
# Because $u^0$ is a separate variable, we could build the $00$ component separately, then the $\mu0$ and $0\nu$ components, and finally the $\mu\nu$ components. Alternatively, for clarity, we could create a temporary variable $u^\mu=\left( u^0, u^i \right)$
# $$\label{step5}$$
# Step 2.1: Construct the electromagnetic stress-energy tensor
# Step 2.1.a: Set up the four-velocity vector
u4U = ixp.zerorank1(DIM=4)
u4U[0] = u4upperZero
for i in range(DIM):
u4U[i+1] = uU[i]
# Step 2.1.b: Build T4EMUU itself
T4EMUU = ixp.zerorank2(DIM=4)
for mu in range(4):
for nu in range(4):
# Term 1: b^2 u^{\mu} u^{\nu}
T4EMUU[mu][nu] = smallb2*u4U[mu]*u4U[nu]
for mu in range(4):
for nu in range(4):
# Term 2: b^2 / 2 g^{\mu \nu}
T4EMUU[mu][nu] += smallb2*g4UU[mu][nu]/2
for mu in range(4):
for nu in range(4):
# Term 3: -b^{\mu} b^{\nu}
T4EMUU[mu][nu] += -smallb4U[mu]*smallb4U[nu]
#
# # Evolution equation for $\tilde{S}_i$
# <a id='step7'></a>
#
# ## Step 3.0: Construct the evolution equation for $\tilde{S}_i$ \[Back to [top](#top)\]
#
# Finally, we will return our attention to the time evolution equation (from eq. 13 of the [original paper](https://arxiv.org/pdf/1704.00599.pdf)),
# \begin{align}
# \partial_t \tilde{S}_i &= - \partial_j \underbrace{\left( \alpha \sqrt{\gamma} T^j_{{\rm EM} i} \right)}_{\rm SevolParenUD} + \frac{1}{2} \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu} \\
# &= - \partial_j{\rm SevolParenUD[i][j]} + \frac{1}{2} \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu} .
# \end{align}
# We will first take construct ${\rm SevolParenUD}$, then use its derivatives to construct the evolution equation. Note that
# \begin{align}
# {\rm SevolParenUD[i][j]} &= \alpha \sqrt{\gamma} T^j_{{\rm EM} i} \\
# &= \alpha \sqrt{\gamma} g_{\mu i} T^{\mu j}_{\rm EM}.
# \end{align}
# $$\label{step7}$$
# Step 3.0: Construct the evolution equation for \tilde{S}_i
# Here, we set up the necessary machinery to take FD derivatives of alpha * sqrt(gamma)
global gammaUU,gammadet
gammaUU = ixp.register_gridfunctions_for_single_rank2("AUX","gammaUU","sym01")
gammadet = gri.register_gridfunctions("AUX","gammadet")
gammaUU, gammadet = ixp.symm_matrix_inverter3x3(gammaDD)
alpsqrtgam = alpha*sp.sqrt(gammadet)
global SevolParenUD
SevolParenUD = ixp.register_gridfunctions_for_single_rank2("AUX","SevolParenUD","nosym")
SevolParenUD = ixp.zerorank2()
for i in range(DIM):
for j in range (DIM):
for mu in range(4):
SevolParenUD[j][i] += alpsqrtgam * g4DD[mu][i+1] * T4EMUU[mu][j+1]
SevolParenUD_dD = ixp.declarerank3("SevolParenUD_dD","nosym")
global Stilde_rhsD
Stilde_rhsD = ixp.zerorank1()
# The first term: \alpha \sqrt{\gamma} \partial_j T^j_{{\rm EM} i}
for i in range(DIM):
for j in range(DIM):
Stilde_rhsD[i] += -SevolParenUD_dD[j][i][j]
# The second term: \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu} / 2
for i in range(DIM):
for mu in range(4):
for nu in range(4):
Stilde_rhsD[i] += alpsqrtgam * T4EMUU[mu][nu] * g4DDdD[mu][nu][i+1] / 2
# # Evolution equations for $A_i$ and $\Phi$
# <a id='step8'></a>
#
# ## Step 4.0: Construct the evolution equations for $A_i$ and $[\sqrt{\gamma}\Phi]$ \[Back to [top](#top)\]
#
# We will also need to evolve the vector potential $A_i$. This evolution is given as eq. 17 in the [$\texttt{GiRaFFE}$](https://arxiv.org/pdf/1704.00599.pdf) paper:
# $$\boxed{\partial_t A_i = \epsilon_{ijk} v^j B^k - \partial_i (\underbrace{\alpha \Phi - \beta^j A_j}_{\rm AevolParen}),}$$
# where $\epsilon_{ijk} = [ijk] \sqrt{\gamma}$ is the antisymmetric Levi-Civita tensor, the drift velocity $v^i = u^i/u^0$, $\gamma$ is the determinant of the three metric, $B^k$ is the magnetic field, $\alpha$ is the lapse, and $\beta$ is the shift.
# The scalar electric potential $\Phi$ is also evolved by eq. 19:
# $$\boxed{\partial_t [\sqrt{\gamma} \Phi] = -\partial_j (\underbrace{\alpha\sqrt{\gamma} \gamma^{ij} A_i - \beta^j [\sqrt{\gamma} \Phi]}_{\rm PevolParenU[j]}) - \xi \alpha [\sqrt{\gamma} \Phi],}$$
# with $\xi$ chosen as a damping factor.
#
# ### Step 4.0.a: Construct some useful auxiliary gridfunctions for the other evolution equations
#
# After declaring a some needed quantities, we will also define the parenthetical terms (underbrace above) that we need to take derivatives of. That way, we can take finite-difference derivatives easily. Note that the above equations incorporate the fact that $\gamma^{ij}$ is the appropriate raising operator for $A_i$: $A^j = \gamma^{ij} A_i$. This is correct since $n_\mu A^\mu = 0$, where $n_\mu$ is a normal to the hypersurface, so $A^0=0$ (according to Sec. II, subsection C of [the "Improved EM gauge condition" paper of Etienne *et al*](https://arxiv.org/pdf/1110.4633.pdf)).
# $$\label{step8}$$
# Step 4.0: Construct the evolution equations for A_i and sqrt(gamma)Phi
# Step 4.0.a: Construct some useful auxiliary gridfunctions for the other evolution equations
xi = par.Cparameters("REAL",thismodule,"xi", 0.1) # The (dimensionful) Lorenz damping factor. Recommendation: set to ~1.5/max(delta t).
# Define sqrt(gamma)Phi as psi6Phi
psi6Phi = gri.register_gridfunctions("EVOL","psi6Phi")
Phi = psi6Phi / sp.sqrt(gammadet)
# We'll define a few extra gridfunctions to avoid complicated derivatives
global AevolParen,PevolParenU
AevolParen = gri.register_gridfunctions("AUX","AevolParen")
PevolParenU = ixp.register_gridfunctions_for_single_rank1("AUX","PevolParenU")
# {\rm AevolParen} = \alpha \Phi - \beta^j A_j
AevolParen = alpha*Phi
for j in range(DIM):
AevolParen += -betaU[j] * AD[j]
# {\rm PevolParenU[j]} = \alpha\sqrt{\gamma} \gamma^{ij} A_i - \beta^j [\sqrt{\gamma} \Phi]
for j in range(DIM):
PevolParenU[j] = -betaU[j] * psi6Phi
for i in range(DIM):
PevolParenU[j] += alpsqrtgam * gammaUU[i][j] * AD[i]
AevolParen_dD = ixp.declarerank1("AevolParen_dD")
PevolParenU_dD = ixp.declarerank2("PevolParenU_dD","nosym")
# ### Step 4.0.b: Complete the construction of the evolution equations for $A_i$ and $[\sqrt{\gamma}\Phi]$
#
# Now to set the evolution equations ([eqs. 17 and 19](https://arxiv.org/pdf/1704.00599.pdf)), recalling that the drift velocity $v^i = u^i/u^0$:
# \begin{align}
# \partial_t A_i &= \epsilon_{ijk} v^j B^k - \partial_i (\alpha \Phi - \beta^j A_j) \\
# &= \epsilon_{ijk} \frac{u^j}{u^0} B^k - {\rm AevolParen\_dD[i]} \\
# \partial_t [\sqrt{\gamma} \Phi] &= -\partial_j \left(\left(\alpha\sqrt{\gamma}\right)A^j - \beta^j [\sqrt{\gamma} \Phi]\right) - \xi \alpha [\sqrt{\gamma} \Phi] \\
# &= -{\rm PevolParenU\_dD[j][j]} - \xi \alpha [\sqrt{\gamma} \Phi]. \\
# \end{align}
# Step 4.0.b: Construct the actual evolution equations for A_i and sqrt(gamma)Phi
global A_rhsD,psi6Phi_rhs
A_rhsD = ixp.zerorank1()
psi6Phi_rhs = sp.sympify(0)
# We already have a handy function to define the Levi-Civita symbol in WeylScalars
import WeylScal4NRPy.WeylScalars_Cartesian as weyl
# Initialize the Levi-Civita tensor by setting it equal to the Levi-Civita symbol
LeviCivitaSymbolDDD = weyl.define_LeviCivitaSymbol_rank3()
LeviCivitaTensorDDD = ixp.zerorank3()
#LeviCivitaTensorUUU = ixp.zerorank3()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
LeviCivitaTensorDDD[i][j][k] = LeviCivitaSymbolDDD[i][j][k] * sp.sqrt(gammadet)
#LeviCivitaTensorUUU[i][j][k] = LeviCivitaSymbolDDD[i][j][k] / sp.sqrt(gammadet)
for i in range(DIM):
A_rhsD[i] = -AevolParen_dD[i]
for j in range(DIM):
for k in range(DIM):
A_rhsD[i] += LeviCivitaTensorDDD[i][j][k]*(uU[j]/u4upperZero)*BU[k]
psi6Phi_rhs = -xi*alpha*psi6Phi
for j in range(DIM):
psi6Phi_rhs += -PevolParenU_dD[j][j]
def output_Enforce_Detgammabar_Constraint_Ccode():
# Set spatial dimension (must be 3 for BSSN)
DIM = 3
# Then we set the coordinate system for the numerical grid
rfm.reference_metric(
) # Create ReU, ReDD needed for rescaling B-L initial data, generating BSSN RHSs, etc.
# We will need the h_{ij} quantities defined within BSSN_RHSs
# below when we enforce the gammahat=gammabar constraint
# Step 1: All barred quantities are defined in terms of BSSN rescaled gridfunctions,
# which we declare here in case they haven't yet been declared elsewhere.
Bq.declare_BSSN_gridfunctions_if_not_declared_already()
hDD = Bq.hDD
Bq.BSSN_basic_tensors()
gammabarDD = Bq.gammabarDD
# First define the Kronecker delta:
KroneckerDeltaDD = ixp.zerorank2()
for i in range(DIM):
KroneckerDeltaDD[i][i] = sp.sympify(1)
# The detgammabar in BSSN_RHSs is set to detgammahat when BSSN_RHSs::detgbarOverdetghat_equals_one=True (default),
# so we manually compute it here:
dummygammabarUU, detgammabar = ixp.symm_matrix_inverter3x3(gammabarDD)
# Next apply the constraint enforcement equation above.
hprimeDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
hprimeDD[i][j] = \
(sp.Abs(rfm.detgammahat) / detgammabar) ** (sp.Rational(1, 3)) * (KroneckerDeltaDD[i][j] + hDD[i][j]) \
- KroneckerDeltaDD[i][j]
enforce_detg_constraint_vars = [ \
lhrh(lhs=gri.gfaccess("in_gfs", "hDD00"), rhs=hprimeDD[0][0]),
lhrh(lhs=gri.gfaccess("in_gfs", "hDD01"), rhs=hprimeDD[0][1]),
lhrh(lhs=gri.gfaccess("in_gfs", "hDD02"), rhs=hprimeDD[0][2]),
lhrh(lhs=gri.gfaccess("in_gfs", "hDD11"), rhs=hprimeDD[1][1]),
lhrh(lhs=gri.gfaccess("in_gfs", "hDD12"), rhs=hprimeDD[1][2]),
lhrh(lhs=gri.gfaccess("in_gfs", "hDD22"), rhs=hprimeDD[2][2])]
enforce_gammadet_string = fin.FD_outputC(
"returnstring",
enforce_detg_constraint_vars,
params="outCverbose=False,preindent=0,includebraces=False")
with open("BSSN/enforce_detgammabar_constraint.h", "w") as file:
indent = " "
file.write(
"void enforce_detgammabar_constraint(const int Nxx_plus_2NGHOSTS[3],REAL *xx[3], REAL *in_gfs) {\n\n"
)
file.write(
lp.loop(["i2", "i1", "i0"], ["0", "0", "0"], [
"Nxx_plus_2NGHOSTS[2]", "Nxx_plus_2NGHOSTS[1]",
"Nxx_plus_2NGHOSTS[0]"
], ["1", "1", "1"], [
"#pragma omp parallel for", " const REAL xx2 = xx[2][i2];",
" const REAL xx1 = xx[1][i1];"
], "", "const REAL xx0 = xx[0][i0];\n" + enforce_gammadet_string))
file.write("}\n")
print(
"Output C implementation of det(gammabar) constraint to file BSSN/enforce_detgammabar_constraint.h"
)
def FishboneMoncriefID():
par.set_parval_from_str("reference_metric::CoordSystem","Cartesian")
rfm.reference_metric()
#Set the spatial dimension parameter to 3.
par.set_parval_from_str("grid::DIM", 3)
DIM = par.parval_from_str("grid::DIM")
gPhys4UU = ixp.register_gridfunctions_for_single_rank2("AUX","gPhys4UU", "sym01", DIM=4)
KDD = ixp.register_gridfunctions_for_single_rank2("EVOL","KDD", "sym01")
# Variables needed for initial data given in spherical basis
r, th, ph = gri.register_gridfunctions("AUX",["r","th","ph"])
r_in,r_at_max_density,a,M = par.Cparameters("REAL",thismodule,["r_in","r_at_max_density","a","M"])
kappa,gamma = par.Cparameters("REAL",thismodule,["kappa","gamma"])
LorentzFactor = gri.register_gridfunctions("AUX","LorentzFactor")
def calculate_l_at_r(r):
l = sp.sqrt(M/r**3) * (r**4 + r**2*a**2 - 2*M*r*a**2 - a*sp.sqrt(M*r)*(r**2-a**2))
l /= r**2 - 3*M*r + 2*a*sp.sqrt(M*r)
return l
# First compute angular momentum at r_at_max_density, TAKING POSITIVE ROOT. This way disk is co-rotating with black hole
# Eq 3.8:
l = calculate_l_at_r(r_at_max_density)
# Eq 3.6:
# First compute the radially-independent part of the log of the enthalpy, ln_h_const
Delta = r**2 - 2*M*r + a**2
Sigma = r**2 + a**2*sp.cos(th)**2
A = (r**2 + a**2)**2 - Delta*a**2*sp.sin(th)**2
# Next compute the radially-dependent part of log(enthalpy), ln_h
tmp3 = sp.sqrt(1 + 4*l**2*Sigma**2*Delta/(A*sp.sin(th))**2)
# Term 1 of Eq 3.6
ln_h = sp.Rational(1,2)*sp.log( ( 1 + tmp3) / (Sigma*Delta/A))
# Term 2 of Eq 3.6
ln_h -= sp.Rational(1,2)*tmp3
# Term 3 of Eq 3.6
ln_h -= 2*a*M*r*l/A
# Next compute the radially-INdependent part of log(enthalpy), ln_h
# Note that there is some typo in the expression for these terms given in Eq 3.6, so we opt to just evaluate
# negative of the first three terms at r=r_in and th=pi/2 (the integration constant), as described in
# the text below Eq. 3.6, basically just copying the above lines of code.
# Delin = Delta_in ; Sigin = Sigma_in ; Ain = A_in .
Delin = r_in**2 - 2*M*r_in + a**2
Sigin = r_in**2 + a**2*sp.cos(sp.pi/2)**2
Ain = (r_in**2 + a**2)**2 - Delin*a**2*sp.sin(sp.pi/2)**2
tmp3in = sp.sqrt(1 + 4*l**2*Sigin**2*Delin/(Ain*sp.sin(sp.pi/2))**2)
# Term 4 of Eq 3.6
mln_h_in = -sp.Rational(1,2)*sp.log( ( 1 + tmp3in) / (Sigin*Delin/Ain))
# Term 5 of Eq 3.6
mln_h_in += sp.Rational(1,2)*tmp3in
# Term 6 of Eq 3.6
mln_h_in += 2*a*M*r_in*l/Ain
global hm1
hm1 = sp.exp(ln_h + mln_h_in) - 1
global rho_initial
rho_initial,Pressure_initial = gri.register_gridfunctions("AUX",["rho_initial","Pressure_initial"])
# Python 3.4 + sympy 1.0.0 has a serious problem taking the power here, hangs forever.
# so instead we use the identity x^{1/y} = exp( [1/y] * log(x) )
# Original expression (works with Python 2.7 + sympy 0.7.4.1):
# rho_initial = ( hm1*(gamma-1)/(kappa*gamma) )**(1/(gamma - 1))
# New expression (workaround):
rho_initial = sp.exp( (1/(gamma-1)) * sp.log( hm1*(gamma-1)/(kappa*gamma) ))
Pressure_initial = kappa * rho_initial**gamma
# Eq 3.3: First compute exp(-2 chi), assuming Boyer-Lindquist coordinates
# Eq 2.16: chi = psi - nu, so
# Eq 3.5 -> exp(-2 chi) = exp(-2 (psi - nu)) = exp(2 nu)/exp(2 psi)
exp2nu = Sigma*Delta / A
exp2psi = A*sp.sin(th)**2 / Sigma
expm2chi = exp2nu / exp2psi
# Eq 3.3: Next compute u_(phi).
u_pphip = sp.sqrt((-1 + sp.sqrt(1 + 4*l**2*expm2chi))/2)
# Eq 2.13: Compute u_(t)
u_ptp = -sp.sqrt(1 + u_pphip**2)
# Next compute spatial components of 4-velocity in Boyer-Lindquist coordinates:
uBL4D = ixp.zerorank1(DIM=4) # Components 1 and 2: u_r = u_theta = 0
# Eq 2.12 (typo): u_(phi) = e^(-psi) u_phi -> u_phi = e^(psi) u_(phi)
uBL4D[3] = sp.sqrt(exp2psi)*u_pphip
# Assumes Boyer-Lindquist coordinates:
omega = 2*a*M*r/A
# Eq 2.13: u_(t) = 1/sqrt(exp2nu) * ( u_t + omega*u_phi )
# --> u_t = u_(t) * sqrt(exp2nu) - omega*u_phi
# --> u_t = u_ptp * sqrt(exp2nu) - omega*uBL4D[3]
uBL4D[0] = u_ptp*sp.sqrt(exp2nu) - omega*uBL4D[3]
# Eq. 3.5:
# w = 2*a*M*r/A;
# Eqs. 3.5 & 2.1:
# gtt = -Sig*Del/A + w^2*Sin[th]^2*A/Sig;
# gtp = w*Sin[th]^2*A/Sig;
# gpp = Sin[th]^2*A/Sig;
# FullSimplify[Inverse[{{gtt,gtp},{gtp,gpp}}]]
gPhys4BLUU = ixp.zerorank2(DIM=4)
gPhys4BLUU[0][0] = -A/(Delta*Sigma)
# DO NOT NEED TO SET gPhys4BLUU[1][1] or gPhys4BLUU[2][2]!
gPhys4BLUU[0][3] = gPhys4BLUU[3][0] = -2*a*M*r/(Delta*Sigma)
gPhys4BLUU[3][3] = -4*a**2*M**2*r**2/(Delta*A*Sigma) + Sigma**2/(A*Sigma*sp.sin(th)**2)
uBL4U = ixp.zerorank1(DIM=4)
for i in range(4):
for j in range(4):
uBL4U[i] += gPhys4BLUU[i][j]*uBL4D[j]
# https://github.com/atchekho/harmpi/blob/master/init.c
# Next transform Boyer-Lindquist velocity to Kerr-Schild basis:
transformBLtoKS = ixp.zerorank2(DIM=4)
for i in range(4):
transformBLtoKS[i][i] = 1
transformBLtoKS[0][1] = 2*r/(r**2 - 2*r + a*a)
transformBLtoKS[3][1] = a/(r**2 - 2*r + a*a)
uKS4U = ixp.zerorank1(DIM=4)
for i in range(4):
for j in range(4):
uKS4U[i] += transformBLtoKS[i][j]*uBL4U[j]
# Adopt the Kerr-Schild metric for Fishbone-Moncrief disks
# http://gravity.psu.edu/numrel/jclub/jc/Cook___LivRev_2000-5.pdf
# Alternatively, Appendix of https://arxiv.org/pdf/1704.00599.pdf
rhoKS2 = r**2 + a**2*sp.cos(th)**2 # Eq 79 of Cook's Living Review article
DeltaKS = r**2 - 2*M*r + a**2 # Eq 79 of Cook's Living Review article
alphaKS = 1/sp.sqrt(1 + 2*M*r/rhoKS2)
betaKSU = ixp.zerorank1()
betaKSU[0] = alphaKS**2*2*M*r/rhoKS2
gammaKSDD = ixp.zerorank2()
gammaKSDD[0][0] = 1 + 2*M*r/rhoKS2
gammaKSDD[0][2] = gammaKSDD[2][0] = -(1 + 2*M*r/rhoKS2)*a*sp.sin(th)**2
gammaKSDD[1][1] = rhoKS2
gammaKSDD[2][2] = (r**2 + a**2 + 2*M*r/rhoKS2 * a**2*sp.sin(th)**2) * sp.sin(th)**2
AA = a**2 * sp.cos(2*th) + a**2 + 2*r**2
BB = AA + 4*M*r
DD = sp.sqrt(2*M*r / (a**2 * sp.cos(th)**2 + r**2) + 1)
KDD[0][0] = DD*(AA + 2*M*r)/(AA**2*BB) * (4*M*(a**2 * sp.cos(2*th) + a**2 - 2*r**2))
KDD[0][1] = KDD[1][0] = DD/(AA*BB) * 8*a**2*M*r*sp.sin(th)*sp.cos(th)
KDD[0][2] = KDD[2][0] = DD/AA**2 * (-2*a*M*sp.sin(th)**2 * (a**2 * sp.cos(2*th) + a**2 - 2*r**2))
KDD[1][1] = DD/BB * 4*M*r**2
KDD[1][2] = KDD[2][1] = DD/(AA*BB) * (-8*a**3*M*r*sp.sin(th)**3*sp.cos(th))
KDD[2][2] = DD/(AA**2*BB) * \
(2*M*r*sp.sin(th)**2 * (a**4*(r-M)*sp.cos(4*th) + a**4*(M+3*r) +
4*a**2*r**2*(2*r-M) + 4*a**2*r*sp.cos(2*th)*(a**2 + r*(M+2*r)) + 8*r**5))
# For compatibility, we must compute gPhys4UU
gammaKSUU,gammaKSDET = ixp.symm_matrix_inverter3x3(gammaKSDD)
# See, e.g., Eq. 4.49 of https://arxiv.org/pdf/gr-qc/0703035.pdf , where N = alpha
gPhys4UU[0][0] = -1 / alphaKS**2
for i in range(1,4):
if i>0:
# if the quantity does not have a "4", then it is assumed to be a 3D quantity.
# E.g., betaKSU[] is a spatial vector, with indices ranging from 0 to 2:
gPhys4UU[0][i] = gPhys4UU[i][0] = betaKSU[i-1]/alphaKS**2
for i in range(1,4):
for j in range(1,4):
# if the quantity does not have a "4", then it is assumed to be a 3D quantity.
# E.g., betaKSU[] is a spatial vector, with indices ranging from 0 to 2,
# and gammaKSUU[][] is a spatial tensor, with indices again ranging from 0 to 2.
gPhys4UU[i][j] = gPhys4UU[j][i] = gammaKSUU[i-1][j-1] - betaKSU[i-1]*betaKSU[j-1]/alphaKS**2
A_b = par.Cparameters("REAL",thismodule,"A_b")
A_3vecpotentialD = ixp.zerorank1()
# Set A_phi = A_b*rho_initial FIXME: why is there a sign error?
A_3vecpotentialD[2] = -A_b * rho_initial
BtildeU = ixp.register_gridfunctions_for_single_rank1("EVOL","BtildeU")
# Eq 15 of https://arxiv.org/pdf/1501.07276.pdf:
# B = curl A -> B^r = d_th A_ph - d_ph A_th
BtildeU[0] = sp.diff(A_3vecpotentialD[2],th) - sp.diff(A_3vecpotentialD[1],ph)
# B = curl A -> B^th = d_ph A_r - d_r A_ph
BtildeU[1] = sp.diff(A_3vecpotentialD[0],ph) - sp.diff(A_3vecpotentialD[2],r)
# B = curl A -> B^ph = d_r A_th - d_th A_r
BtildeU[2] = sp.diff(A_3vecpotentialD[1],r) - sp.diff(A_3vecpotentialD[0],th)
# Construct spacetime metric in 3+1 form:
# See, e.g., Eq. 4.49 of https://arxiv.org/pdf/gr-qc/0703035.pdf , where N = alpha
alpha = gri.register_gridfunctions("EVOL",["alpha"])
betaU = ixp.register_gridfunctions_for_single_rank1("EVOL","betaU")
alpha = sp.sqrt(1/(-gPhys4UU[0][0]))
betaU = ixp.zerorank1()
for i in range(3):
betaU[i] = alpha**2 * gPhys4UU[0][i+1]
gammaUU = ixp.zerorank2()
for i in range(3):
for j in range(3):
gammaUU[i][j] = gPhys4UU[i+1][j+1] + betaU[i]*betaU[j]/alpha**2
gammaDD = ixp.register_gridfunctions_for_single_rank2("EVOL","gammaDD","sym01")
gammaDD,igammaDET = ixp.symm_matrix_inverter3x3(gammaUU)
gammaDET = 1/igammaDET
###############
# Next compute g_{\alpha \beta} from lower 3-metric, using
# Eq 4.47 of https://arxiv.org/pdf/gr-qc/0703035.pdf
betaD = ixp.zerorank1()
for i in range(3):
for j in range(3):
betaD[i] += gammaDD[i][j]*betaU[j]
beta2 = sp.sympify(0)
for i in range(3):
beta2 += betaU[i]*betaD[i]
gPhys4DD = ixp.zerorank2(DIM=4)
gPhys4DD[0][0] = -alpha**2 + beta2
for i in range(3):
gPhys4DD[0][i+1] = gPhys4DD[i+1][0] = betaD[i]
for j in range(3):
gPhys4DD[i+1][j+1] = gammaDD[i][j]
###############
# Next compute b^{\mu} using Eqs 23 and 31 of https://arxiv.org/pdf/astro-ph/0503420.pdf
uKS4D = ixp.zerorank1(DIM=4)
for i in range(4):
for j in range(4):
uKS4D[i] += gPhys4DD[i][j] * uKS4U[j]
# Eq 27 of https://arxiv.org/pdf/astro-ph/0503420.pdf
BU = ixp.zerorank1()
for i in range(3):
BU[i] = BtildeU[i]/sp.sqrt(gammaDET)
# Eq 23 of https://arxiv.org/pdf/astro-ph/0503420.pdf
BU0_u = sp.sympify(0)
for i in range(3):
BU0_u += uKS4D[i+1]*BU[i]/alpha
smallbU = ixp.zerorank1(DIM=4)
smallbU[0] = BU0_u / sp.sqrt(4 * sp.pi)
# Eqs 24 and 31 of https://arxiv.org/pdf/astro-ph/0503420.pdf
for i in range(3):
smallbU[i+1] = (BU[i]/alpha + BU0_u*uKS4U[i+1])/(sp.sqrt(4*sp.pi)*uKS4U[0])
smallbD = ixp.zerorank1(DIM=4)
for i in range(4):
for j in range(4):
smallbD[i] += gPhys4DD[i][j]*smallbU[j]
smallb2 = sp.sympify(0)
for i in range(4):
smallb2 += smallbU[i]*smallbD[i]
###############
LorentzFactor = alpha * uKS4U[0]
# Define Valencia 3-velocity v^i_(n), which sets the 3-velocity as measured by normal observers to the spatial slice:
# v^i_(n) = u^i/(u^0*alpha) + beta^i/alpha. See eq 11 of https://arxiv.org/pdf/1501.07276.pdf
Valencia3velocityU = ixp.zerorank1()
for i in range(3):
Valencia3velocityU[i] = uKS4U[i + 1] / (alpha * uKS4U[0]) + betaU[i]
sqrtgamma4DET = sp.symbols("sqrtgamma4DET")
sqrtgamma4DET = sp.sqrt(gammaDET)*alpha
alpha = alpha.subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
for i in range(DIM):
betaU[i] = betaU[i].subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
for j in range(DIM):
gammaDD[i][j] = gammaDD[i][j].subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
KDD[i][j] = KDD[i][j].subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
# GRMHD variables:
# Density and pressure:
hm1 = hm1.subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
rho_initial = rho_initial.subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
Pressure_initial = Pressure_initial.subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
LorentzFactor = LorentzFactor.subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
# "Valencia" three-velocity
for i in range(DIM):
BtildeU[i] = BtildeU[i].subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
uKS4U[i+1] = uKS4U[i+1].subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
Valencia3velocityU[i] = Valencia3velocityU[i].subs(r,rfm.xxSph[0]).subs(th,rfm.xxSph[1]).subs(ph,rfm.xxSph[2])
# Transform initial data to our coordinate system:
# First compute Jacobian and its inverse
drrefmetric__dx_0UDmatrix = sp.Matrix([[sp.diff( rfm.xxSph[0],rfm.xx[0]), sp.diff( rfm.xxSph[0],rfm.xx[1]), sp.diff( rfm.xxSph[0],rfm.xx[2])],
[sp.diff(rfm.xxSph[1],rfm.xx[0]), sp.diff(rfm.xxSph[1],rfm.xx[1]), sp.diff(rfm.xxSph[1],rfm.xx[2])],
[sp.diff(rfm.xxSph[2],rfm.xx[0]), sp.diff(rfm.xxSph[2],rfm.xx[1]), sp.diff(rfm.xxSph[2],rfm.xx[2])]])
dx__drrefmetric_0UDmatrix = drrefmetric__dx_0UDmatrix.inv()
# Declare as gridfunctions the final quantities we will output for the initial data
global IDalpha,IDgammaDD,IDKDD,IDbetaU,IDValencia3velocityU
IDalpha = gri.register_gridfunctions("EVOL","IDalpha")
IDgammaDD = ixp.register_gridfunctions_for_single_rank2("EVOL","IDgammaDD","sym01")
IDKDD = ixp.register_gridfunctions_for_single_rank2("EVOL","IDKDD","sym01")
IDbetaU = ixp.register_gridfunctions_for_single_rank1("EVOL","IDbetaU")
IDValencia3velocityU = ixp.register_gridfunctions_for_single_rank1("EVOL","IDValencia3velocityU")
IDalpha = alpha
for i in range(3):
IDbetaU[i] = 0
IDValencia3velocityU[i] = 0
for j in range(3):
# Matrices are stored in row, column format, so (i,j) <-> (row,column)
IDbetaU[i] += dx__drrefmetric_0UDmatrix[(i,j)]*betaU[j]
IDValencia3velocityU[i] += dx__drrefmetric_0UDmatrix[(i,j)]*Valencia3velocityU[j]
IDgammaDD[i][j] = 0
IDKDD[i][j] = 0
for k in range(3):
for l in range(3):
IDgammaDD[i][j] += drrefmetric__dx_0UDmatrix[(k,i)]*drrefmetric__dx_0UDmatrix[(l,j)]*gammaDD[k][l]
IDKDD[i][j] += drrefmetric__dx_0UDmatrix[(k,i)]*drrefmetric__dx_0UDmatrix[(l,j)]* KDD[k][l]
def MaxwellCartesian_Evol():
#Step 0: Set the spatial dimension parameter to 3.
par.set_parval_from_str("grid::DIM", 3)
DIM = par.parval_from_str("grid::DIM")
# Step 1: Set the finite differencing order to 4.
# (not needed here)
# par.set_parval_from_str("finite_difference::FD_CENTDERIVS_ORDER", 4)
# Step 2: Register gridfunctions that are needed as input.
_psi = gri.register_gridfunctions(
"EVOL", ["psi"]) # lgtm [py/unused-local-variable]
# Step 3a: Declare the rank-1 indexed expressions E_{i}, A_{i},
# and \partial_{i} \psi. Derivative variables like these
# must have an underscore in them, so the finite
# difference module can parse the variable name properly.
ED = ixp.register_gridfunctions_for_single_rank1("EVOL", "ED")
AD = ixp.register_gridfunctions_for_single_rank1("EVOL", "AD")
psi_dD = ixp.declarerank1("psi_dD")
## Step 3b: Declare the conformal metric tensor and its first
# derivative. These are needed to find the Christoffel
# symbols, which we need for covariant derivatives.
gammaDD = ixp.register_gridfunctions_for_single_rank2(
"AUX", "gammaDD", "sym01") # The AUX or EVOL designation is *not*
# used in diagnostic modules.
gammaDD_dD = ixp.declarerank3("gammaDD_dD", "sym01")
gammaDD_dDD = ixp.declarerank4("gammaDD_dDD", "sym01_sym23")
gammaUU, detgamma = ixp.symm_matrix_inverter3x3(gammaDD)
gammaUU_dD = ixp.declarerank3("gammaDD_dD", "sym01")
# Define the Christoffel symbols
GammaUDD = ixp.zerorank3(DIM)
for i in range(DIM):
for k in range(DIM):
for l in range(DIM):
for m in range(DIM):
GammaUDD[i][k][l] += (sp.Rational(1,2))*gammaUU[i][m]*\
(gammaDD_dD[m][k][l] + gammaDD_dD[m][l][k] - gammaDD_dD[k][l][m])
# Step 3b: Declare the rank-2 indexed expression \partial_{j} A_{i},
# which is not symmetric in its indices.
# Derivative variables like these must have an underscore
# in them, so the finite difference module can parse the
# variable name properly.
AD_dD = ixp.declarerank2("AD_dD", "nosym")
# Step 3c: Declare the rank-3 indexed expression \partial_{jk} A_{i},
# which is symmetric in the two {jk} indices.
AD_dDD = ixp.declarerank3("AD_dDD", "sym12")
# Step 4: Calculate first and second covariant derivatives, and the
# necessary contractions.
# First covariant derivative
# D_{j} A_{i} = A_{i,j} - \Gamma^{k}_{ij} A_{k}
AD_dcovD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
AD_dcovD[i][j] = AD_dD[i][j]
for k in range(DIM):
AD_dcovD[i][j] -= GammaUDD[k][i][j] * AD[k]
# First, we must construct the lowered Christoffel symbols:
# \Gamma_{ijk} = \gamma_{il} \Gamma^l_{jk}
# And raise the index on A:
# A^j = \gamma^{ij} A_i
GammaDDD = ixp.zerorank3()
AU = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
AU[j] += gammaUU[i][j] * AD[i]
for k in range(DIM):
for l in range(DIM):
GammaDDD[i][j][k] += gammaDD[i][l] * GammaUDD[l][j][k]
# Covariant second derivative (the bracketed terms):
# D_j D^j A_i = \gamma^{jk} [A_{i,jk} - A^l (\gamma_{li,kj} + \gamma_{kl,ij} - \gamma_{ik,lj})
# + \Gamma_{lik} (\gamma^{lm} A_{m,j} + A_m \gamma^{lm}{}_{,j})
# - (\Gamma^l_{ij} A_{l,k} + \Gamma^l_{jk} A_{i,l})
# + (\Gamma^m_{ij} \Gamma^l_{mk} A_l + \Gamma ^m_{jk} \Gamma^l_{im} A_l)
AD_dcovDD = ixp.zerorank3()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
AD_dcovDD[i][j][k] = AD_dDD[i][j][k]
for l in range(DIM):
# Terms 1 and 3
AD_dcovDD[i][j][k] -= AU[l] * (gammaDD_dDD[l][i][k][j] + gammaDD_dDD[k][l][i][j] - \
gammaDD_dDD[i][k][l][j]) \
+ GammaUDD[l][i][j] * AD_dD[l][k] + GammaUDD[l][j][k] * AD_dD[i][l]
for m in range(DIM):
# Terms 2 and 4
AD_dcovDD[i][j][k] += GammaDDD[l][i][k] * (gammaUU[l][m] * AD_dD[m][j] + AD[m] * gammaUU_dD[l][m][j]) \
+ GammaUDD[m][i][j] * GammaUDD[l][m][k] * AD[l] \
+ GammaUDD[m][j][k] * GammaUDD[l][i][m] * AD[l]
# Covariant divergence
# D_{i} A^{i} = \gamma^{ij} D_{j} A_{i}
DivA = 0
# Gradient of covariant divergence
# DivA_dD_{i} = \gamma^{jk} A_{k;\hat{j}\hat{i}}
DivA_dD = ixp.zerorank1()
# Covariant Laplacian
# LapAD_{i} = \gamma^{jk} A_{i;\hat{j}\hat{k}}
LapAD = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
DivA += gammaUU[i][j] * AD_dcovD[i][j]
for k in range(DIM):
DivA_dD[i] += gammaUU[j][k] * AD_dcovDD[k][j][i]
LapAD[i] += gammaUU[j][k] * AD_dcovDD[i][j][k]
global ArhsD, ErhsD, psi_rhs
system = par.parval_from_str("System_to_use")
if system == "System_I":
# Step 5: Define right-hand sides for the evolution.
print("Warning: System I is less stable!")
ArhsD = ixp.zerorank1()
ErhsD = ixp.zerorank1()
for i in range(DIM):
ArhsD[i] = -ED[i] - psi_dD[i]
ErhsD[i] = -LapAD[i] + DivA_dD[i]
psi_rhs = -DivA
elif system == "System_II":
# We inherit here all of the definitions from System I, above
# Step 7a: Register the scalar auxiliary variable \Gamma
Gamma = gri.register_gridfunctions("EVOL", ["Gamma"])
# Step 7b: Declare the ordinary gradient \partial_{i} \Gamma
Gamma_dD = ixp.declarerank1("Gamma_dD")
# Step 8a: Construct the second covariant derivative of the scalar \psi
# \psi_{;\hat{i}\hat{j}} = \psi_{,i;\hat{j}}
# = \psi_{,ij} - \Gamma^{k}_{ij} \psi_{,k}
psi_dDD = ixp.declarerank2("psi_dDD", "sym01")
psi_dcovDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
psi_dcovDD[i][j] = psi_dDD[i][j]
for k in range(DIM):
psi_dcovDD[i][j] += -GammaUDD[k][i][j] * psi_dD[k]
# Step 8b: Construct the covariant Laplacian of \psi
# Lappsi = ghat^{ij} D_{j} D_{i} \psi
Lappsi = 0
for i in range(DIM):
for j in range(DIM):
Lappsi += gammaUU[i][j] * psi_dcovDD[i][j]
# Step 9: Define right-hand sides for the evolution.
global Gamma_rhs
ArhsD = ixp.zerorank1()
ErhsD = ixp.zerorank1()
for i in range(DIM):
ArhsD[i] = -ED[i] - psi_dD[i]
ErhsD[i] = -LapAD[i] + Gamma_dD[i]
psi_rhs = -Gamma
Gamma_rhs = -Lappsi
else:
print(
"Invalid choice of system: System_to_use must be either System_I or System_II"
)
ED_dD = ixp.declarerank2("ED_dD", "nosym")
global Cviolation
Cviolation = gri.register_gridfunctions("AUX", ["Cviolation"])
Cviolation = sp.sympify(0)
for i in range(DIM):
for j in range(DIM):
Cviolation += gammaUU[i][j] * ED_dD[j][i]
for b in range(DIM):
Cviolation -= gammaUU[i][j] * GammaUDD[b][i][j] * ED[b]
def GiRaFFE_Higher_Order():
#Step 1.0: Set the spatial dimension parameter to 3.
par.set_parval_from_str("grid::DIM", 3)
DIM = par.parval_from_str("grid::DIM")
# Step 1.1: Set the finite differencing order to 4.
#par.set_parval_from_str("finite_difference::FD_CENTDERIVS_ORDER", 4)
thismodule = "GiRaFFE_NRPy"
# M_PI will allow the C code to substitute the correct value
M_PI = par.Cparameters("#define", thismodule, "M_PI", "")
# ADMBase defines the 4-metric in terms of the 3+1 spacetime metric quantities gamma_{ij}, beta^i, and alpha
gammaDD = ixp.register_gridfunctions_for_single_rank2("AUX",
"gammaDD",
"sym01",
DIM=3)
betaU = ixp.register_gridfunctions_for_single_rank1("AUX", "betaU", DIM=3)
alpha = gri.register_gridfunctions("AUX", "alpha")
# GiRaFFE uses the Valencia 3-velocity and A_i, which are defined in the initial data module(GiRaFFEfood)
ValenciavU = ixp.register_gridfunctions_for_single_rank1("AUX",
"ValenciavU",
DIM=3)
AD = ixp.register_gridfunctions_for_single_rank1("EVOL", "AD", DIM=3)
# B^i must be computed at each timestep within GiRaFFE so that the Valencia 3-velocity can be evaluated
BU = ixp.register_gridfunctions_for_single_rank1("AUX", "BU", DIM=3)
# <a id='step3'></a>
#
# ## Step 1.2: Build the four metric $g_{\mu\nu}$, its inverse $g^{\mu\nu}$ and spatial derivatives $g_{\mu\nu,i}$ from ADM 3+1 quantities $\gamma_{ij}$, $\beta^i$, and $\alpha$
#
# $$\label{step3}$$
# \[Back to [top](#top)\]
#
# Notice that the time evolution equation for $\tilde{S}_i$
# $$
# \partial_t \tilde{S}_i = - \partial_j \left( \alpha \sqrt{\gamma} T^j_{{\rm EM} i} \right) + \frac{1}{2} \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu}
# $$
# contains $\partial_i g_{\mu \nu} = g_{\mu\nu,i}$. We will now focus on evaluating this term.
#
# The four-metric $g_{\mu\nu}$ is related to the three-metric $\gamma_{ij}$, index-lowered shift $\beta_i$, and lapse $\alpha$ by
# $$
# g_{\mu\nu} = \begin{pmatrix}
# -\alpha^2 + \beta^k \beta_k & \beta_j \\
# \beta_i & \gamma_{ij}
# \end{pmatrix}.
# $$
# This tensor and its inverse have already been built by the u0_smallb_Poynting__Cartesian.py module ([documented here](Tutorial-u0_smallb_Poynting-Cartesian.ipynb)), so we can simply load the module and import the variables.
# Step 1.2: import u0_smallb_Poynting__Cartesian.py to set
# the four metric and its inverse. This module also sets b^2 and u^0.
import u0_smallb_Poynting__Cartesian.u0_smallb_Poynting__Cartesian as u0b
u0b.compute_u0_smallb_Poynting__Cartesian(gammaDD, betaU, alpha,
ValenciavU, BU)
betaD = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
betaD[i] += gammaDD[i][j] * betaU[j]
# We will now pull in the four metric and its inverse.
import BSSN.ADMBSSN_tofrom_4metric as AB4m # NRPy+: ADM/BSSN <-> 4-metric conversions
AB4m.g4DD_ito_BSSN_or_ADM("ADM")
g4DD = AB4m.g4DD
AB4m.g4UU_ito_BSSN_or_ADM("ADM")
g4UU = AB4m.g4UU
# Next we compute spatial derivatives of the metric, $\partial_i g_{\mu\nu} = g_{\mu\nu,i}$, written in terms of the three-metric, shift, and lapse. Simply taking the derivative of the expression for $g_{\mu\nu}$ above, we find
# $$
# g_{\mu\nu,l} = \begin{pmatrix}
# -2\alpha \alpha_{,l} + \beta^k_{\ ,l} \beta_k + \beta^k \beta_{k,l} & \beta_{i,l} \\
# \beta_{j,l} & \gamma_{ij,l}
# \end{pmatrix}.
# $$
#
# Notice the derivatives of the shift vector with its indexed lowered, $\beta_{i,j} = \partial_j \beta_i$. This can be easily computed in terms of the given ADMBase quantities $\beta^i$ and $\gamma_{ij}$ via:
# \begin{align}
# \beta_{i,j} &= \partial_j \beta_i \\
# &= \partial_j (\gamma_{ik} \beta^k) \\
# &= \gamma_{ik} \partial_j\beta^k + \beta^k \partial_j \gamma_{ik} \\
# \beta_{i,j} &= \gamma_{ik} \beta^k_{\ ,j} + \beta^k \gamma_{ik,j}.
# \end{align}
#
# Since this expression mixes Greek and Latin indices, we will need to store the expressions for each of the three spatial derivatives as separate variables.
#
# So, we will first set
# $$ g_{00,l} = \underbrace{-2\alpha \alpha_{,l}}_{\rm Term\ 1} + \underbrace{\beta^k_{\ ,l} \beta_k}_{\rm Term\ 2} + \underbrace{\beta^k \beta_{k,l}}_{\rm Term\ 3} $$
# Step 1.2, cont'd: Build spatial derivatives of the four metric
# Step 1.2.a: Declare derivatives of grid functions. These will be handled by FD_outputC
alpha_dD = ixp.declarerank1("alpha_dD")
betaU_dD = ixp.declarerank2("betaU_dD", "nosym")
gammaDD_dD = ixp.declarerank3("gammaDD_dD", "sym01")
# Step 1.2.b: These derivatives will be constructed analytically.
betaDdD = ixp.zerorank2()
g4DDdD = ixp.zerorank3(DIM=4)
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
# \gamma_{ik} \beta^k_{,j} + \beta^k \gamma_{ik,j}
betaDdD[i][j] += gammaDD[i][k] * betaU_dD[k][j] + betaU[
k] * gammaDD_dD[i][k][j]
# Step 1.2.c: Set the 00 components
# Step 1.2.c.i: Term 1: -2\alpha \alpha_{,l}
for l in range(DIM):
g4DDdD[0][0][l + 1] = -2 * alpha * alpha_dD[l]
# Step 1.2.c.ii: Term 2: \beta^k_{\ ,l} \beta_k
for l in range(DIM):
for k in range(DIM):
g4DDdD[0][0][l + 1] += betaU_dD[k][l] * betaD[k]
# Step 1.2.c.iii: Term 3: \beta^k \beta_{k,l}
for l in range(DIM):
for k in range(DIM):
g4DDdD[0][0][l + 1] += betaU[k] * betaDdD[k][l]
# Now we will contruct the other components of $g_{\mu\nu,l}$. We will first construct
# $$ g_{i0,l} = g_{0i,l} = \beta_{i,l}, $$
# then
# $$ g_{ij,l} = \gamma_{ij,l} $$
# Step 1.2.d: Set the i0 and 0j components
for l in range(DIM):
for i in range(DIM):
# \beta_{i,l}
g4DDdD[i + 1][0][l + 1] = g4DDdD[0][i + 1][l + 1] = betaDdD[i][l]
#Step 1.2.e: Set the ij components
for l in range(DIM):
for i in range(DIM):
for j in range(DIM):
# \gamma_{ij,l}
g4DDdD[i + 1][j + 1][l + 1] = gammaDD_dD[i][j][l]
# <a id='step4'></a>
#
# # $T^{\mu\nu}_{\rm EM}$ and its derivatives
#
# Now that the metric and its derivatives are out of the way, let's return to the evolution equation for $\tilde{S}_i$,
# $$
# \partial_t \tilde{S}_i = - \partial_j \left( \alpha \sqrt{\gamma} T^j_{{\rm EM} i} \right) + \frac{1}{2} \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu}.
# $$
# We turn our focus now to $T^j_{{\rm EM} i}$ and its derivatives. To this end, we start by computing $T^{\mu \nu}_{\rm EM}$ (from eq. 27 of [Paschalidis & Shapiro's paper on their GRFFE code](https://arxiv.org/pdf/1310.3274.pdf)):
#
# $$\boxed{T^{\mu \nu}_{\rm EM} = b^2 u^{\mu} u^{\nu} + \frac{b^2}{2} g^{\mu \nu} - b^{\mu} b^{\nu}.}$$
#
# Notice that $T^{\mu\nu}_{\rm EM}$ is written in terms of
#
# * $b^\mu$, the 4-component magnetic field vector, related to the comoving magnetic field vector $B^i_{(u)}$
# * $u^\mu$, the 4-velocity
# * $g^{\mu \nu}$, the inverse 4-metric
#
# However, $\texttt{GiRaFFE}$ has access to only the following quantities, requiring in the following sections that we write the above quantities in terms of the following ones:
#
# * $\gamma_{ij}$, the 3-metric
# * $\alpha$, the lapse
# * $\beta^i$, the shift
# * $A_i$, the vector potential
# * $B^i$, the magnetic field (we assume only in the grid interior, not the ghost zones)
# * $\left[\sqrt{\gamma}\Phi\right]$, the zero-component of the vector potential $A_\mu$, times the square root of the determinant of the 3-metric
# * $v_{(n)}^i$, the Valencia 3-velocity
# * $u^0$, the zero-component of the 4-velocity
#
# ## Step 2.0: $u^i$ and $b^i$ and related quantities
# $$\label{step4}$$
# \[Back to [top](#top)\]
#
# We begin by importing what we can from u0_smallb_Poynting__Cartesian.py. We will need the four-velocity $u^\mu$, which is related to the Valencia 3-velocity $v^i_{(n)}$ used directly by $\texttt{GiRaFFE}$ (see also [Duez, et al, eqs. 53 and 56](https://arxiv.org/pdf/astro-ph/0503420.pdf))
# \begin{align}
# u^i &= u^0 (\alpha v^i_{(n)} - \beta^i), \\
# u_j &= \alpha u^0 \gamma_{ij} v^i_{(n)},
# \end{align}
# and $v^i_{(n)}$ is the Valencia three-velocity. These have already been constructed in terms of the Valencia 3-velocity and other 3+1 ADM quantities by the u0_smallb_Poynting__Cartesian.py module, so we can simply import these variables:
# Step 2.0: u^i, b^i, and related quantities
# Step 2.0.a: import the four-velocity, as written in terms of the Valencia 3-velocity
global uD, uU
uD = ixp.register_gridfunctions_for_single_rank1("AUX", "uD")
uU = ixp.register_gridfunctions_for_single_rank1("AUX", "uU")
u4upperZero = gri.register_gridfunctions("AUX", "u4upperZero")
for i in range(DIM):
uD[i] = u0b.uD[i].subs(u0b.u0, u4upperZero)
uU[i] = u0b.uU[i].subs(u0b.u0, u4upperZero)
# We also need the magnetic field 4-vector $b^{\mu}$, which is related to the magnetic field by [eqs. 23, 24, and 31 in Duez, et al](https://arxiv.org/pdf/astro-ph/0503420.pdf):
# \begin{align}
# b^0 &= \frac{1}{\sqrt{4\pi}} B^0_{\rm (u)} = \frac{u_j B^j}{\sqrt{4\pi}\alpha}, \\
# b^i &= \frac{1}{\sqrt{4\pi}} B^i_{\rm (u)} = \frac{B^i + (u_j B^j) u^i}{\sqrt{4\pi}\alpha u^0}, \\
# \end{align}
# where $B^i$ is the variable tracked by the HydroBase thorn in the Einstein Toolkit. Again, these have already been built by the u0_smallb_Poynting__Cartesian.py module, so we can simply import the variables.
# Step 2.0.b: import the small b terms
smallb4U = ixp.zerorank1(DIM=4)
smallb4D = ixp.zerorank1(DIM=4)
for mu in range(4):
smallb4U[mu] = u0b.smallb4U[mu].subs(u0b.u0, u4upperZero)
smallb4D[mu] = u0b.smallb4D[mu].subs(u0b.u0, u4upperZero)
smallb2 = u0b.smallb2etk.subs(u0b.u0, u4upperZero)
# <a id='step5'></a>
#
# ## Step 2.1: Construct all components of the electromagnetic stress-energy tensor $T^{\mu \nu}_{\rm EM}$
# $$\label{step5}$$
#
# \[Back to [top](#top)\]
#
# We now have all the pieces to calculate the stress-energy tensor,
# $$T^{\mu \nu}_{\rm EM} = \underbrace{b^2 u^{\mu} u^{\nu}}_{\rm Term\ 1} +
# \underbrace{\frac{b^2}{2} g^{\mu \nu}}_{\rm Term\ 2}
# - \underbrace{b^{\mu} b^{\nu}}_{\rm Term\ 3}.$$
# Because $u^0$ is a separate variable, we could build the $00$ component separately, then the $\mu0$ and $0\nu$ components, and finally the $\mu\nu$ components. Alternatively, for clarity, we could create a temporary variable $u^\mu=\left( u^0, u^i \right)$
# Step 2.1: Construct the electromagnetic stress-energy tensor
# Step 2.1.a: Set up the four-velocity vector
u4U = ixp.zerorank1(DIM=4)
u4U[0] = u4upperZero
for i in range(DIM):
u4U[i + 1] = uU[i]
# Step 2.1.b: Build T4EMUU itself
T4EMUU = ixp.zerorank2(DIM=4)
for mu in range(4):
for nu in range(4):
# Term 1: b^2 u^{\mu} u^{\nu}
T4EMUU[mu][nu] = smallb2 * u4U[mu] * u4U[nu]
for mu in range(4):
for nu in range(4):
# Term 2: b^2 / 2 g^{\mu \nu}
T4EMUU[mu][nu] += smallb2 * g4UU[mu][nu] / 2
for mu in range(4):
for nu in range(4):
# Term 3: -b^{\mu} b^{\nu}
T4EMUU[mu][nu] += -smallb4U[mu] * smallb4U[nu]
# <a id='step6'></a>
#
# # Step 2.2: Derivatives of the electromagnetic stress-energy tensor
# $$\label{step6}$$
#
# \[Back to [top](#top)\]
#
# If we look at the evolution equation, we see that we will need spatial derivatives of $T^{\mu\nu}_{\rm EM}$. When confronted with derivatives of complicated expressions, it is generally convenient to declare those expressions as gridfunctions themselves, allowing NRPy+ to take finite-difference derivatives of the expressions. This can even reduce the truncation error associated with the finite differences, because the alternative is to use a function of several finite-difference derivatives, allowing more error to accumulate than the extra gridfunction will introduce. While we will use that technique for some of the subexpressions of $T^{\mu\nu}_{\rm EM}$, we don't want to rely on it for the whole expression; doing so would require us to take the derivative of the magnetic field $B^i$, which is itself found by finite-differencing the vector potential $A_i$. Thus $B^i$ cannot be *consistently* defined in ghost zones. To potentially reduce numerical errors induced by inconsistent finite differencing, we will differentiate $T^{\mu\nu}_{\rm EM}$ term-by-term so that finite-difference derivatives of $A_i$ appear.
#
# We will now now take these spatial derivatives of $T^{\mu\nu}_{\rm EM}$, applying the chain rule until it is only in terms of basic gridfunctions and their derivatives: $\alpha$, $\beta^i$, $\gamma_{ij}$, $A_i$, and the four-velocity $u^i$. Along the way, we will also set up useful temporary variables representing the steps of the chain rule. (Notably, *all* of these quantities will be written in terms of $A_i$ and its derivatives):
#
# * $B^i$ (already computed in terms of $A_k$, via $B^i = \epsilon^{ijk} \partial_j A_k$),
# * $B^i_{,l}$,
# * $b^i$ and $b_i$ (already computed),
# * $b^i_{,k}$,
# * $b^2$ (already computed),
# * and $\left(b^2\right)_{,j}$.
#
# (The variables not already computed will not be seen by the ETK, as they are written in terms of $A_i$ and its derivatives; they simply help to organize the NRPy+ code.)
#
# So then,
# \begin{align}
# \partial_j T^{j}_{{\rm EM} i} &= \partial_j (g_{\mu i} T^{\mu j}_{\rm EM}) \\
# &= \partial_j \left[g_{\mu i} \left(b^2 u^j u^\mu + \frac{b^2}{2} g^{j\mu} - b^j b^\mu\right)\right] \\
# &= \underbrace{g_{\mu i,j} T^{\mu j}_{\rm EM}}_{\rm Term\ A} + g_{\mu i} \left( \underbrace{\partial_j \left(b^2 u^j u^\mu \right)}_{\rm Term\ B} + \underbrace{\partial_j \left(\frac{b^2}{2} g^{j\mu}\right)}_{\rm Term\ C} - \underbrace{\partial_j \left(b^j b^k\right)}_{\rm Term\ D} \right) \\
# \end{align}
# Following the product and chain rules for each term, we find that
# \begin{align}
# {\rm Term\ B} &= \partial_j (b^2 u^j u^\mu) \\
# &= \partial_j b^2 u^j u^\mu + b^2 \partial_j u^j u^\mu + b^2 u^j \partial_j u^\mu \\
# &= \underbrace{\left(b^2\right)_{,j} u^j u^\mu + b^2 u^j_{,j} u^\mu + b^2 u^j u^{\mu}_{,j}}_{\rm To\ Term\ 2\ below} \\
# {\rm Term\ C} &= \partial_j \left(\frac{b^2}{2} g^{j\mu}\right) \\
# &= \frac{1}{2} \left( \partial_j b^2 g^{j\mu} + b^2 \partial_j g^{j\mu} \right) \\
# &= \underbrace{\frac{1}{2} \left(b^2\right)_{,j} g^{j\mu} + \frac{b^2}{2} g^{j\mu}_{\ ,j}}_{\rm To\ Term\ 3\ below} \\
# {\rm Term\ D} &= \partial_j (b^j b^\mu) \\
# &= \underbrace{b^j_{,j} b^\mu + b^j b^\mu_{,j}}_{\rm To\ Term\ 2\ below}\\
# \end{align}
#
# So,
# \begin{align}
# \partial_j T^{j}_{{\rm EM} i} &= g_{\mu i,j} T^{\mu j}_{\rm EM} \\
# &+ g_{\mu i} \left(\left(b^2\right)_{,j} u^j u^\mu +b^2 u^j_{,j} u^\mu + b^2 u^j u^{\mu}_{,j} + \frac{1}{2}\left(b^2\right)_{,j} g^{j\mu} + \frac{b^2}{2} g^{j\mu}_{\ ,j} + b^j_{,j} b^\mu + b^j b^\mu_{,j}\right);
# \end{align}
# We will rearrange this once more, collecting the $b^2$ terms together, noting that Term A will become Term 1:
# \begin{align}
# \partial_j T^{j}_{{\rm EM} i} =& \
# \underbrace{g_{\mu i,j} T^{\mu j}_{\rm EM}}_{\rm Term\ 1} \\
# & + \underbrace{g_{\mu i} \left( b^2 u^j_{,j} u^\mu + b^2 u^j u^\mu_{,j} + \frac{b^2}{2} g^{j\mu}_{\ ,j} + b^j_{,j} b^\mu + b^j b^\mu_{,j} \right)}_{\rm Term\ 2} \\
# & + \underbrace{g_{\mu i} \left( \left(b^2\right)_{,j} u^j u^\mu + \frac{1}{2} \left(b^2\right)_{,j} g^{j\mu} \right).}_{\rm Term\ 3} \\
# \end{align}
#
# <a id='table2'></a>
#
# **List of Derivatives**
# $$\label{table2}$$
#
# Note that this is in terms of the derivatives of several other quantities:
#
# * [Step 2.2.a](#capitalBideriv): $B^i_{,l}$: Since $b^i$ is itself a function of $B^i$, we will first need the derivatives $B^i_{,l}$ in terms of the evolved quantity $A_i$ (the vector potential).
# * [Step 2.2.b](#bideriv): $b^i_{,k}$: Once we have $B^i_{,l}$ we can evaluate derivatives of $b^i$, $b^i_{,k}$
# * [Step 2.2.c](#b2deriv): The derivative of $b^2 = g_{\mu\nu} b^\mu b^\nu$, $\left(b^2\right)_{,j}$
# * [Step 2.2.d](#gupijderiv): Derivatives of $g^{\mu\nu}$, $g^{\mu\nu}_{\ ,k}$
# * [Step 2.2.e](#alltogether): Putting it together: $\partial_j T^{j}_{{\rm EM} i}$
# * [Step 2.2.e.i](#alltogether1): Putting it together: Term 1
# * [Step 2.2.e.ii](#alltogether2): Putting it together: Term 2
# * [Step 2.2.e.iii](#alltogether3): Putting it together: Term 3
# <a id='capitalBideriv'></a>
#
# ## Step 2.2.a: Derivatives of $B^i$
#
# $$\label{capitalbideriv}$$
#
# \[Back to [List of Derivatives](#table2)\]
#
# First, we will build the derivatives of the magnetic field. Since $b^i$ is a function of $B^i$, we will start from the definition of $B^i$ in terms of $A_i$, $B^i = \frac{[ijk]}{\sqrt{\gamma}} \partial_j A_k$. We will first apply the product rule, noting that the symbol $[ijk]$ consists purely of the integers $-1, 0, 1$ and thus can be treated as a constant in this process.
# \begin{align}
# B^i_{,l} &= \partial_l \left( \frac{[ijk]}{\sqrt{\gamma}} \partial_j A_k \right) \\
# &= [ijk] \partial_l \left( \frac{1}{\sqrt{\gamma}}\right) \partial_j A_k + \frac{[ijk]}{\sqrt{\gamma}} \partial_l \partial_j A_k \\
# &= [ijk]\left(-\frac{\gamma_{,l}}{2\gamma^{3/2}}\right) \partial_j A_k + \frac{[ijk]}{\sqrt{\gamma}} \partial_l \partial_j A_k \\
# \end{align}
# Now, we will substitute back in for the definition of the Levi-Civita tensor: $\epsilon^{ijk} = [ijk] / \sqrt{\gamma}$. Then we will substitute the magnetic field $B^i$ back in.
# \begin{align}
# B^i_{,l} &= -\frac{\gamma_{,l}}{2\gamma} \epsilon^{ijk} \partial_j A_k + \epsilon^{ijk} \partial_l \partial_j A_k \\
# &= -\frac{\gamma_{,l}}{2\gamma} B^i + \epsilon^{ijk} A_{k,jl}, \\
# \end{align}
#
# Thus, the expression we are left with for the derivatives of the magnetic field is:
# \begin{align}
# B^i_{,l} &= \underbrace{-\frac{\gamma_{,l}}{2\gamma} B^i}_{\rm Term\ 1} + \underbrace{\epsilon^{ijk} A_{k,jl}}_{\rm Term\ 2}, \\
# \end{align}
# where $\epsilon^{ijk} = [ijk] / \sqrt{\gamma}$ is the antisymmetric Levi-Civita tensor and $\gamma$ is the determinant of the three-metric.
#
# Step 2.2: Derivatives of the electromagnetic stress-energy tensor
# We already have a handy function to define the Levi-Civita symbol in WeylScalars
import WeylScal4NRPy.WeylScalars_Cartesian as weyl
# Initialize the Levi-Civita tensor by setting it equal to the Levi-Civita symbol
LeviCivitaSymbolDDD = weyl.define_LeviCivitaSymbol_rank3()
LeviCivitaTensorDDD = ixp.zerorank3()
LeviCivitaTensorUUU = ixp.zerorank3()
global gammaUU, gammadet
gammaUU = ixp.register_gridfunctions_for_single_rank2(
"AUX", "gammaUU", "sym01")
gammadet = gri.register_gridfunctions("AUX", "gammadet")
gammaUU, gammadet = ixp.symm_matrix_inverter3x3(gammaDD)
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
LeviCivitaTensorDDD[i][j][
k] = LeviCivitaSymbolDDD[i][j][k] * sp.sqrt(gammadet)
LeviCivitaTensorUUU[i][j][
k] = LeviCivitaSymbolDDD[i][j][k] / sp.sqrt(gammadet)
AD_dD = ixp.declarerank2("AD_dD", "nosym")
# Step 2.2.a: Construct the derivatives of the magnetic field.
gammadet_dD = ixp.declarerank1("gammadet_dD")
AD_dDD = ixp.declarerank3("AD_dDD", "sym12")
# The other partial derivatives of B^i
BUdD = ixp.zerorank2()
for i in range(DIM):
for l in range(DIM):
# Term 1: -\gamma_{,l} / (2\gamma) B^i
BUdD[i][l] = -gammadet_dD[l] * BU[i] / (2 * gammadet)
for i in range(DIM):
for l in range(DIM):
for j in range(DIM):
for k in range(DIM):
# Term 2: \epsilon^{ijk} A_{k,jl}
BUdD[i][
l] += LeviCivitaTensorUUU[i][j][k] * AD_dDD[k][j][l]
# <a id='bideriv'></a>
#
# ## Step 2.2.b: Derivatives of $b^i$
# $$\label{bideriv}$$
#
# \[Back to [List of Derivatives](#table2)\]
#
# Now, we will code the derivatives of the spatial components of $b^{\mu}$, $b^i$:
# $$
# b^i_{,k} = \frac{1}{\sqrt{4 \pi}} \frac{\left(\alpha u^0\right) \left(B^i_{,k} + u_{j,k} B^j u^i + u_j B^j_{,k} u^i + u_j B^j u^i_{,k}\right) - \left(B^i + (u_j B^j) u^i\right) \partial_k \left(\alpha u^0\right)}{\left(\alpha u^0\right)^2}.
# $$
#
# We should note that while $b^\mu$ is a four-vector (and the code reflects this: $\text{smallb4U}$ and $\text{smallb4U}$ have $\text{DIM=4}$), we only need the spatial components. We will only focus on the spatial components for the moment.
#
#
# Let's go into a little more detail on where this comes from. We start from the definition $$b^i = \frac{B^i + (u_j B^j) u^i}{\sqrt{4\pi}\alpha u^0};$$ we then apply the quotient rule:
# \begin{align}
# b^i_{,k} &= \frac{\left(\sqrt{4\pi}\alpha u^0\right) \partial_k \left(B^i + (u_j B^j) u^i\right) - \left(B^i + (u_j B^j) u^i\right) \partial_k \left(\sqrt{4\pi}\alpha u^0\right)}{\left(\sqrt{4\pi}\alpha u^0\right)^2} \\
# &= \frac{1}{\sqrt{4 \pi}} \frac{\left(\alpha u^0\right) \partial_k \left(B^i + (u_j B^j) u^i\right) - \left(B^i + (u_j B^j) u^i\right) \partial_k \left(\alpha u^0\right)}{\left(\alpha u^0\right)^2} \\
# \end{align}
# Note that $\left( \alpha u^0 \right)$ is being used as its own gridfunction, so $\partial_k \left(a u^0\right)$ will be finite-differenced by NRPy+ directly. We will also apply the product rule to the term $\partial_k \left(B^i + (u_j B^j) u^i\right) = B^i_{,k} + u_{j,k} B^j u^i + u_j B^j_{,k} u^i + u_j B^j u^i_{,k}$. So,
# $$ b^i_{,k} = \frac{1}{\sqrt{4 \pi}} \frac{\left(\alpha u^0\right) \left(B^i_{,k} + u_{j,k} B^j u^i + u_j B^j_{,k} u^i + u_j B^j u^i_{,k}\right) - \left(B^i + (u_j B^j) u^i\right) \partial_k \left(\alpha u^0\right)}{\left(\alpha u^0\right)^2}. $$
#
# It will be easier to code this up if we rearrange these terms to group together the terms that involve contractions over $j$. Doing that, we find
# $$
# b^i_{,k} = \frac{\overbrace{\alpha u^0 B^i_{,k} - B^i \partial_k (\alpha u^0)}^{\rm Term\ Num1} + \overbrace{\left( \alpha u^0 \right) \left( u_{j,k} B^j u^i + u_j B^j_{,k} u^i + u_j B^j u^i_{,k} \right)}^{\rm Term\ Num2.a} - \overbrace{\left( u_j B^j u^i \right) \partial_k \left( \alpha u^0 \right) }^{\rm Term\ Num2.b}}{\underbrace{\sqrt{4 \pi} \left( \alpha u^0 \right)^2}_{\rm Term\ Denom}}.
# $$
global u0alpha
u0alpha = gri.register_gridfunctions("AUX", "u0alpha")
u0alpha = alpha * u4upperZero
u0alpha_dD = ixp.declarerank1("u0alpha_dD")
uU_dD = ixp.declarerank2("uU_dD", "nosym")
uD_dD = ixp.declarerank2("uD_dD", "nosym")
# Step 2.2.b: Construct derivatives of the small b vector
# smallbUdD represents the derivative of smallb4U
smallbUdD = ixp.zerorank2()
for i in range(DIM):
for k in range(DIM):
# Term Num1: \alpha u^0 B^i_{,k} - B^i \partial_k (\alpha u^0)
smallbUdD[i][k] += u0alpha * BUdD[i][k] - BU[i] * u0alpha_dD[k]
for i in range(DIM):
for k in range(DIM):
for j in range(DIM):
# Term Num2.a: terms that require contractions over k, and thus an extra loop.
# ( \alpha u^0 ) ( u_{j,k} B^j u^i
# + u_j B^j_{,k} u^i
# + u_j B^j u^i_{,k} )
smallbUdD[i][k] += u0alpha * (uD_dD[j][k] * BU[j] * uU[i] +
uD[j] * BUdD[j][k] * uU[i] +
uD[j] * BU[j] * uU_dD[i][k])
for i in range(DIM):
for k in range(DIM):
for j in range(DIM):
#Term 2.b (More contractions over k): ( u_j B^j u^i ) ( \alpha u^0 ),k
smallbUdD[i][k] += -(uD[j] * BU[j] * uU[i]) * u0alpha_dD[k]
for i in range(DIM):
for k in range(DIM):
# Term Denom: Divide the numerator by sqrt(4 pi) * (alpha u^0)^2
smallbUdD[i][k] /= sp.sqrt(4 * M_PI) * u0alpha * u0alpha
# <a id='b2deriv'></a>
#
# ## Step 2.2.c: Derivative of $b^2$
# $$\label{b2deriv}$$
#
# \[Back to [List of Derivatives](#table2)\]
#
# Here, we will take the derivative of $b^2 = g_{\mu\nu} b^\mu b^\nu$. Using the product rule,
# \begin{align}
# \left(b^2\right)_{,j} &= \partial_j \left( g_{\mu\nu} b^\mu b^\nu \right) \\
# &= g_{\mu\nu,j} b^\mu b^\nu + g_{\mu\nu} b^\mu_{,j} b^\nu + g_{\mu\nu} b^\mu b^\nu_{,j} \\
# &= g_{\mu\nu,j} b^\mu b^\nu + 2 g_{\mu\nu} b^\mu_{,j} b^\nu.
# \end{align}
# We have already defined the spatial derivatives of the four-metric $g_{\mu\nu,j}$ in [this section](#step3); we have also defined the spatial derivatives of spatial components of $b^\mu$, $b^i_{,k}$ in [this section](#bideriv). Notice the above expression requires spatial derivatives of the *zeroth* component of $b^\mu$ as well, $b^0_{,j}$, which we will now compute. Starting with the definition, and applying the quotient rule:
# \begin{align}
# b^0 &= \frac{u_k B^k}{\sqrt{4\pi}\alpha}, \\
# \rightarrow b^0_{,j} &= \frac{1}{\sqrt{4\pi}} \frac{\alpha \left( u_{k,j} B^k + u_k B^k_{,j} \right) - u_k B^k \alpha_{,j}}{\alpha^2} \\
# &= \frac{\alpha u_{k,j} B^k + \alpha u_k B^k_{,j} - \alpha_{,j} u_k B^k}{\sqrt{4\pi} \alpha^2}.
# \end{align}
# We will first code the numerator, and then divide through by the denominator.
# Step 2.2.c: Construct the derivative of b^2
# First construct the derivative b^0_{,j}
# This four-vector will make b^2 simpler:
smallb4UdD = ixp.zerorank2(DIM=4)
# Fill in the zeroth component
for j in range(DIM):
for k in range(DIM):
# The numerator: \alpha u_{k,j} B^k
# + \alpha u_k B^k_{,j}
# - \alpha_{,j} u_k B^k
smallb4UdD[0][j + 1] += alpha * uD_dD[k][j] * BU[k] + alpha * uD[
k] * BUdD[k][j] - alpha_dD[j] * uD[k] * BU[k]
for j in range(DIM):
# Divide through by the denominator: \sqrt{4\pi} \alpha^2
smallb4UdD[0][j + 1] /= sp.sqrt(4 * M_PI) * alpha * alpha
# At this point, both $b^0_{\ ,j}$ and $b^i_{\ ,j}$ have been computed, but one exists inconveniently in the $4\times 4$ component $\verb|smallb4UdD[][]|$ and the other in the $3\times 3$ component $\verb|smallbUdD[][]|$. So that we can perform full implied sums over $g_{\mu\nu} b^\mu_{,j} b^\nu$ more conveniently, we will now store all information from $\verb|smallbUdD[i][j]|$ into $\verb|smallb4UdD[i+1][j+1]|$:
# Now, we'll fill out the rest of the four-vector with b^i_{,j} that we derived above.
for i in range(DIM):
for j in range(DIM):
smallb4UdD[i + 1][j + 1] = smallbUdD[i][j]
# Using 4-component (Greek-indexed) quantities, we can now complete our construction of
# $$\left(b^2\right)_{,j} = g_{\mu\nu,j} b^\mu b^\nu + 2 g_{\mu\nu} b^\mu_{,j} b^\nu:$$
smallb2_dD = ixp.zerorank1()
for j in range(DIM):
for mu in range(4):
for nu in range(4):
# g_{\mu\nu,j} b^\mu b^\nu
# + 2 g_{\mu\nu} b^\mu_{,j} b^\nu
smallb2_dD[j] += g4DDdD[mu][nu][j + 1] * smallb4U[
mu] * smallb4U[nu] + 2 * g4DD[mu][nu] * smallb4UdD[mu][
j + 1] * smallb4U[nu]
# <a id='gupijderiv'></a>
#
# ## Step 2.2.d: Derivatives of $g^{\mu\nu}$
# $$\label{gupijderiv}$$
#
# \[Back to [List of Derivatives](#table2)\]
#
# We will need derivatives of the inverse four-metric, as well. Let us begin with $g^{00}$: since $g^{00} = -1/\alpha^2$ ([Gourgoulhon, eq. 4.49](https://arxiv.org/pdf/gr-qc/0703035.pdf)), $$g^{00}_{\ ,k} = \frac{2 \alpha_{,k}}{\alpha^3}$$
#
# Step 2.2.d: Construct derivatives of the components of g^{\mu\nu}
g4UUdD = ixp.zerorank3(DIM=4)
for k in range(DIM):
# 2 \alpha_{,k} / \alpha^3
g4UUdD[0][0][k + 1] = 2 * alpha_dD[k] / alpha**3
# Now, we will code the $g^{i0}_{\ ,k}$ and $g^{0j}_{\ ,k}$ components. According to [Gourgoulhon, eq. 4.49](https://arxiv.org/pdf/gr-qc/0703035.pdf), $g^{i0} = g^{0i} = \beta^i/\alpha^2$, so $$g^{i0}_{\ ,k} = g^{0i}_{\ ,k} = \frac{\alpha^2 \beta^i_{,k} - 2 \beta^i \alpha \alpha_{,k}}{\alpha^4}$$ by the quotient rule. So, we'll code
# $$
# g^{i0} = g^{0i} =
# \underbrace{\frac{\beta^i_{,k}}{\alpha^2}}_{\rm Term\ 1}
# - \underbrace{\frac{2 \beta^i \alpha_{,k}}{\alpha^3}}_{\rm Term\ 2}
# $$
for k in range(DIM):
for i in range(DIM):
# Term 1: \beta^i_{,k} / \alpha^2
g4UUdD[i + 1][0][k +
1] = g4UUdD[0][i +
1][k +
1] = betaU_dD[i][k] / alpha**2
for k in range(DIM):
for i in range(DIM):
# Term 2: -2 \beta^i \alpha_{,k} / \alpha^3
g4UUdD[i + 1][0][k + 1] += -2 * betaU[i] * alpha_dD[k] / alpha**3
g4UUdD[0][i + 1][k + 1] += -2 * betaU[i] * alpha_dD[k] / alpha**3
# We will also need derivatives of the spatial part of the inverse four-metric: since $g^{ij} = \gamma^{ij} - \frac{\beta^i \beta^j}{\alpha^2}$ ([Gourgoulhon, eq. 4.49](https://arxiv.org/pdf/gr-qc/0703035.pdf)),
# \begin{align}
# g^{ij}_{\ ,k} &= \gamma^{ij}_{\ ,k} - \frac{\alpha^2 \partial_k (\beta^i \beta^j) - \beta^i \beta^j \partial_k \alpha^2}{(\alpha^2)^2} \\
# &= \gamma^{ij}_{\ ,k} - \frac{\alpha^2\beta^i \beta^j_{,k}+\alpha^2\beta^i_{,k} \beta^j-2\beta^i \beta^j \alpha \alpha_{,k}}{\alpha^4}. \\
# &= \gamma^{ij}_{\ ,k} - \frac{\alpha\beta^i \beta^j_{,k}+\alpha\beta^i_{,k} \beta^j-2\beta^i \beta^j \alpha_{,k}}{\alpha^3} \\
# g^{ij}_{\ ,k} &= \underbrace{\gamma^{ij}_{\ ,k}}_{\rm Term\ 1} - \underbrace{\frac{\beta^i \beta^j_{,k}}{\alpha^2}}_{\rm Term\ 2} - \underbrace{\frac{\beta^i_{,k} \beta^j}{\alpha^2}}_{\rm Term\ 3} + \underbrace{\frac{2\beta^i \beta^j \alpha_{,k}}{\alpha^3}}_{\rm Term\ 4}. \\
# \end{align}
#
gammaUU_dD = ixp.declarerank3("gammaUU_dD", "sym01")
# The spatial derivatives of the spatial components of the four metric:
# Term 1: \gamma^{ij}_{\ ,k}
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
g4UUdD[i + 1][j + 1][k + 1] = gammaUU_dD[i][j][k]
# Term 2: - \beta^i \beta^j_{,k} / \alpha^2
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
g4UUdD[i + 1][j +
1][k +
1] += -betaU[i] * betaU_dD[j][k] / alpha**2
# Term 3: - \beta^i_{,k} \beta^j / \alpha^2
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
g4UUdD[i + 1][j +
1][k +
1] += -betaU_dD[i][k] * betaU[j] / alpha**2
# Term 4: 2\beta^i \beta^j \alpha_{,k}\alpha^3
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
g4UUdD[i + 1][j + 1][
k + 1] += 2 * betaU[i] * betaU[j] * alpha_dD[k] / alpha**3
# <a id='alltogether'></a>
#
# ## Step 2.2.e: Putting it together:
# $$\label{alltogether}$$
#
# \[Back to [List of Derivatives](#table2)\]
#
# So, we can now put it all together, starting from the expression we derived above in [Step 2.2](#step6):
# \begin{align}
# \partial_j T^{j}_{{\rm EM} i} =& \
# \underbrace{g_{\mu i,j} T^{\mu j}_{\rm EM}}_{\rm Term\ 1} \\
# & + \underbrace{g_{\mu i} \left( b^2 u^j_{,j} u^\mu + b^2 u^j u^\mu_{,j} + \frac{b^2}{2} g^{j\mu}_{\ ,j} + b^j_{,j} b^\mu + b^j b^\mu_{,j} \right)}_{\rm Term\ 2} \\
# & + \underbrace{g_{\mu i} \left( \left(b^2\right)_{,j} u^j u^\mu + \frac{1}{2} \left(b^2\right)_{,j} g^{j\mu} \right).}_{\rm Term\ 3} \\
# \end{align}
#
# <a id='alltogether1'></a>
#
# ### Step 2.2.e.i: Putting it together: Term 1
# $$\label{alltogether1}$$
#
# \[Back to [List of Derivatives](#table2)\]
#
# We will now construct this term by term. Term 1 is straightforward: $${\rm Term\ 1} = \gamma_{\mu i,j} T^{\mu j}_{\rm EM}.$$
# Step 2.2.e: Construct TEMUDdD_contracted itself
# Step 2.2.e.i
TEMUDdD_contracted = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
for mu in range(4):
# Term 1: g_{\mu i,j} T^{\mu j}_{\rm EM}
TEMUDdD_contracted[i] += g4DDdD[mu][i + 1][j +
1] * T4EMUU[mu][j +
1]
# We'll need derivatives of u4U for the next part:
u4UdD = ixp.zerorank2(DIM=4)
u4upperZero_dD = ixp.declarerank1(
"u4upperZero_dD"
) # Note that derivatives can't be done in 4-D with the current version of NRPy
for i in range(DIM):
u4UdD[0][i + 1] = u4upperZero_dD[i]
for i in range(DIM):
for j in range(DIM):
u4UdD[i + 1][j + 1] = uU_dD[i][j]
# <a id='alltogether2'></a>
#
# ### Step 2.2.e.ii: Putting it together: Term 2
# $$\label{alltogether2}$$
#
# \[Back to [List of Derivatives](#table2)\]
#
# We will now add $${\rm Term\ 2} = g_{\mu i} \left( \underbrace{b^2 u^j_{,j} u^\mu}_{\rm Term\ 2a} + \underbrace{b^2 u^j u^\mu_{,j}}_{\rm Term\ 2b} + \underbrace{\frac{b^2}{2} g^{j\mu}_{\ ,j}}_{\rm Term\ 2c} + \underbrace{b^j_{,j} b^\mu}_{\rm Term\ 2d} + \underbrace{b^j b^\mu_{,j}}_{\rm Term\ 2e} \right)$$ to $\partial_j T^{j}_{{\rm EM} i}$. These are the terms that involve contractions over $k$ (but no metric derivatives like Term 1 had).
#
# Step 2.2.e.ii
for i in range(DIM):
for j in range(DIM):
for mu in range(4):
# Term 2a: g_{\mu i} b^2 u^j_{,j} u^\mu
TEMUDdD_contracted[i] += g4DD[mu][
i + 1] * smallb2 * uU_dD[j][j] * u4U[mu]
for i in range(DIM):
for j in range(DIM):
for mu in range(4):
# Term 2b: g_{\mu i} b^2 u^j u^\mu_{,j}
TEMUDdD_contracted[i] += g4DD[mu][
i + 1] * smallb2 * uU[j] * u4UdD[mu][j + 1]
for i in range(DIM):
for j in range(DIM):
for mu in range(4):
# Term 2c: g_{\mu i} b^2 g^{j \mu}_{,j} / 2
TEMUDdD_contracted[i] += g4DD[mu][i + 1] * smallb2 * g4UUdD[
j + 1][mu][j + 1] / 2
for i in range(DIM):
for j in range(DIM):
for mu in range(4):
# Term 2d: g_{\mu i} b^j_{,j} b^\mu
TEMUDdD_contracted[i] += g4DD[mu][
i + 1] * smallbUdD[j][j] * smallb4U[mu]
for i in range(DIM):
for j in range(DIM):
for mu in range(4):
# Term 2e: g_{\mu i} b^j b^\mu_{,j}
TEMUDdD_contracted[i] += g4DD[mu][i + 1] * smallb4U[
j + 1] * smallb4UdD[mu][j + 1]
# <a id='alltogether3'></a>
#
# ### Step 2.2.e.iii: Putting it together: Term 3
# $$\label{alltogether3}$$
#
# \[Back to [List of Derivatives](#table2)\]
#
# Now, we will add $${\rm Term\ 3} = g_{\mu i} \left( \underbrace{\left(b^2\right)_{,j} u^j u^\mu}_{\rm Term\ 3a} + \underbrace{\frac{1}{2} \left(b^2\right)_{,j} g^{j\mu}}_{\rm Term\ 3b} \right).$$
# Step 2.2.e.iii
for i in range(DIM):
for j in range(DIM):
for mu in range(4):
# Term 3a: g_{\mu i} ( b^2 )_{,j} u^j u^\mu
TEMUDdD_contracted[i] += g4DD[mu][
i + 1] * smallb2_dD[j] * uU[j] * u4U[mu]
for i in range(DIM):
for j in range(DIM):
for mu in range(4):
# Term 3b: g_{mu i} ( b^2 )_{,j} g^{j\mu} / 2
TEMUDdD_contracted[i] += g4DD[mu][
i + 1] * smallb2_dD[j] * g4UU[j + 1][mu] / 2
#
# # Evolution equation for $\tilde{S}_i$
# <a id='step7'></a>
#
# ## Step 3.0: Construct the evolution equation for $\tilde{S}_i$
# $$\label{step7}$$
#
# \[Back to [top](#top)\]
#
# Finally, we will return our attention to the time evolution equation (from eq. 13 of the [original paper](https://arxiv.org/pdf/1704.00599.pdf)),
# \begin{align}
# \partial_t \tilde{S}_i &= - \partial_j \left( \alpha \sqrt{\gamma} T^j_{{\rm EM} i} \right) + \frac{1}{2} \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu} \\
# &= -T^j_{{\rm EM} i} \partial_j (\alpha \sqrt{\gamma}) - \alpha \sqrt{\gamma} \partial_j T^j_{{\rm EM} i} + \frac{1}{2} \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu} \\
# &= \underbrace{-g_{i\mu} T^{\mu j}_{\rm EM} \partial_j (\alpha \sqrt{\gamma})
# }_{\rm Term\ 1} - \underbrace{\alpha \sqrt{\gamma} \partial_j T^j_{{\rm EM} i}}_{\rm Term\ 2} + \underbrace{\frac{1}{2} \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu}}_{\rm Term\ 3} .
# \end{align}
# We will first take derivatives of $\alpha \sqrt{\gamma}$, then construct each term in turn.
# Step 3.0: Construct the evolution equation for \tilde{S}_i
# Here, we set up the necessary machinery to take FD derivatives of alpha * sqrt(gamma)
global alpsqrtgam
alpsqrtgam = gri.register_gridfunctions("AUX", "alpsqrtgam")
alpsqrtgam = alpha * sp.sqrt(gammadet)
alpsqrtgam_dD = ixp.declarerank1("alpsqrtgam_dD")
global Stilde_rhsD
Stilde_rhsD = ixp.zerorank1()
# The first term: g_{i\mu} T^{\mu j}_{\rm EM} \partial_j (\alpha \sqrt{\gamma})
for i in range(DIM):
for j in range(DIM):
for mu in range(4):
Stilde_rhsD[i] += -g4DD[i + 1][mu] * T4EMUU[mu][
j + 1] * alpsqrtgam_dD[j]
# The second term: \alpha \sqrt{\gamma} \partial_j T^j_{{\rm EM} i}
for i in range(DIM):
Stilde_rhsD[i] += -alpsqrtgam * TEMUDdD_contracted[i]
# The third term: \alpha \sqrt{\gamma} T^{\mu \nu}_{\rm EM} \partial_i g_{\mu \nu} / 2
for i in range(DIM):
for mu in range(4):
for nu in range(4):
Stilde_rhsD[i] += alpsqrtgam * T4EMUU[mu][nu] * g4DDdD[mu][nu][
i + 1] / 2
# # Evolution equations for $A_i$ and $\Phi$
# <a id='step8'></a>
#
# ## Step 4.0: Construct the evolution equations for $A_i$ and $[\sqrt{\gamma}\Phi]$
# $$\label{step8}$$
#
# \[Back to [top](#top)\]
#
# We will also need to evolve the vector potential $A_i$. This evolution is given as eq. 17 in the [$\texttt{GiRaFFE}$](https://arxiv.org/pdf/1704.00599.pdf) paper:
# $$\boxed{\partial_t A_i = \epsilon_{ijk} v^j B^k - \partial_i (\underbrace{\alpha \Phi - \beta^j A_j}_{\rm AevolParen}),}$$
# where $\epsilon_{ijk} = [ijk] \sqrt{\gamma}$ is the antisymmetric Levi-Civita tensor, the drift velocity $v^i = u^i/u^0$, $\gamma$ is the determinant of the three metric, $B^k$ is the magnetic field, $\alpha$ is the lapse, and $\beta$ is the shift.
# The scalar electric potential $\Phi$ is also evolved by eq. 19:
# $$\boxed{\partial_t [\sqrt{\gamma} \Phi] = -\partial_j (\underbrace{\alpha\sqrt{\gamma}A^j - \beta^j [\sqrt{\gamma} \Phi]}_{\rm PevolParenU[j]}) - \xi \alpha [\sqrt{\gamma} \Phi],}$$
# with $\xi$ chosen as a damping factor.
#
# ### Step 4.0.a: Construct some useful auxiliary gridfunctions for the other evolution equations
#
# After declaring a some needed quantities, we will also define the parenthetical terms (underbrace above) that we need to take derivatives of. That way, we can take finite-difference derivatives easily. Note that we use $A^j = \gamma^{ij} A_i$, while $A_i$ (with $\Phi$) is technically a four-vector; this is justified, however, since $n_\mu A^\mu = 0$, where $n_\mu$ is a normal to the hypersurface, $A^0=0$ (according to Sec. II, subsection C of [this paper](https://arxiv.org/pdf/1110.4633.pdf)).
# Step 4.0: Construct the evolution equations for A_i and sqrt(gamma)Phi
# Step 4.0.a: Construct some useful auxiliary gridfunctions for the other evolution equations
xi = par.Cparameters(
"REAL", thismodule, "xi", 0.1
) # The (dimensionful) Lorenz damping factor. Recommendation: set to ~1.5/max(delta t).
# Define sqrt(gamma)Phi as psi6Phi
psi6Phi = gri.register_gridfunctions("EVOL", "psi6Phi")
Phi = psi6Phi / sp.sqrt(gammadet)
# We'll define a few extra gridfunctions to avoid complicated derivatives
global AevolParen, PevolParenU
AevolParen = gri.register_gridfunctions("AUX", "AevolParen")
PevolParenU = ixp.register_gridfunctions_for_single_rank1(
"AUX", "PevolParenU")
# {\rm AevolParen} = \alpha \Phi - \beta^j A_j
AevolParen = alpha * Phi
for j in range(DIM):
AevolParen += -betaU[j] * AD[j]
# {\rm PevolParenU[j]} = \alpha\sqrt{\gamma} \gamma^{ij} A_i - \beta^j [\sqrt{\gamma} \Phi]
for j in range(DIM):
PevolParenU[j] = -betaU[j] * psi6Phi
for i in range(DIM):
PevolParenU[j] += alpha * sp.sqrt(gammadet) * gammaUU[i][j] * AD[i]
AevolParen_dD = ixp.declarerank1("AevolParen_dD")
PevolParenU_dD = ixp.declarerank2("PevolParenU_dD", "nosym")
# ### Step 4.0.b: Construct the actual evolution equations for $A_i$ and $[\sqrt{\gamma}\Phi]$
#
# Now to set the evolution equations ([eqs. 17 and 19](https://arxiv.org/pdf/1704.00599.pdf)), recalling that the drift velocity $v^i = u^i/u^0$:
# \begin{align}
# \partial_t A_i &= \epsilon_{ijk} v^j B^k - \partial_i (\alpha \Phi - \beta^j A_j) \\
# &= \epsilon_{ijk} \frac{u^j}{u^0} B^k - {\rm AevolParen\_dD[i]} \\
# \partial_t [\sqrt{\gamma} \Phi] &= -\partial_j \left(\left(\alpha\sqrt{\gamma}\right)A^j - \beta^j [\sqrt{\gamma} \Phi]\right) - \xi \alpha [\sqrt{\gamma} \Phi] \\
# &= -{\rm PevolParenU\_dD[j][j]} - \xi \alpha [\sqrt{\gamma} \Phi]. \\
# \end{align}
# Step 4.0.b: Construct the actual evolution equations for A_i and sqrt(gamma)Phi
global A_rhsD, psi6Phi_rhs
A_rhsD = ixp.zerorank1()
psi6Phi_rhs = sp.sympify(0)
for i in range(DIM):
A_rhsD[i] = -AevolParen_dD[i]
for j in range(DIM):
for k in range(DIM):
A_rhsD[i] += LeviCivitaTensorDDD[i][j][k] * (
uU[j] / u4upperZero) * BU[k]
psi6Phi_rhs = -xi * alpha * psi6Phi
for j in range(DIM):
psi6Phi_rhs += -PevolParenU_dD[j][j]
def Convert_Spherical_or_Cartesian_ADM_to_BSSN_curvilinear(
CoordType_in, Sph_r_th_ph_or_Cart_xyz, gammaDD_inSphorCart,
KDD_inSphorCart, alpha_inSphorCart, betaU_inSphorCart, BU_inSphorCart):
# This routine converts the ADM variables
# $$\left\{\gamma_{ij}, K_{ij}, \alpha, \beta^i\right\}$$
# in Spherical or Cartesian basis+coordinates, first to the BSSN variables
# in the chosen reference_metric::CoordSystem coordinate system+basis:
# $$\left\{\bar{\gamma}_{i j},\bar{A}_{i j},\phi, K, \bar{\Lambda}^{i}, \alpha, \beta^i, B^i\right\},$$
# and then to the rescaled variables:
# $$\left\{h_{i j},a_{i j},\phi, K, \lambda^{i}, \alpha, \mathcal{V}^i, \mathcal{B}^i\right\}.$$
# The ADM & BSSN formalisms only work in 3D; they are 3+1 decompositions of Einstein's equations.
# To implement axisymmetry or spherical symmetry, simply set all spatial derivatives in
# the relevant angular directions to zero; DO NOT SET DIM TO ANYTHING BUT 3.
# Step 0: Set spatial dimension (must be 3 for BSSN)
DIM = 3
# Step 0: Copy gammaSphDD_in to gammaSphDD, KSphDD_in to KSphDD, etc.
# This ensures that the input arrays are not modified below;
# modifying them would result in unexpected effects outside
# this function.
alphaSphorCart = alpha_inSphorCart
betaSphorCartU = ixp.zerorank1()
BSphorCartU = ixp.zerorank1()
gammaSphorCartDD = ixp.zerorank2()
KSphorCartDD = ixp.zerorank2()
for i in range(DIM):
betaSphorCartU[i] = betaU_inSphorCart[i]
BSphorCartU[i] = BU_inSphorCart[i]
for j in range(DIM):
gammaSphorCartDD[i][j] = gammaDD_inSphorCart[i][j]
KSphorCartDD[i][j] = KDD_inSphorCart[i][j]
# Make sure that rfm.reference_metric() has been called.
# We'll need the variables it defines throughout this module.
if rfm.have_already_called_reference_metric_function == False:
print(
"Error. Called Convert_Spherical_ADM_to_BSSN_curvilinear() without"
)
print(
" first setting up reference metric, by calling rfm.reference_metric()."
)
exit(1)
# Step 1: All input quantities are in terms of r,th,ph or x,y,z. We want them in terms
# of xx0,xx1,xx2, so here we call sympify_integers__replace_rthph() to replace
# r,th,ph or x,y,z, respectively, with the appropriate functions of xx0,xx1,xx2
# as defined for this particular reference metric in reference_metric.py's
# xxSph[] or xxCart[], respectively:
# Note that substitution only works when the variable is not an integer. Hence the
# if isinstance(...,...) stuff:
def sympify_integers__replace_rthph_or_Cartxyz(obj, rthph_or_xyz,
rthph_or_xyz_of_xx):
if isinstance(obj, int):
return sp.sympify(obj)
else:
return obj.subs(rthph_or_xyz[0], rthph_or_xyz_of_xx[0]).\
subs(rthph_or_xyz[1], rthph_or_xyz_of_xx[1]).\
subs(rthph_or_xyz[2], rthph_or_xyz_of_xx[2])
r_th_ph_or_Cart_xyz_of_xx = []
if CoordType_in == "Spherical":
r_th_ph_or_Cart_xyz_of_xx = rfm.xxSph
elif CoordType_in == "Cartesian":
r_th_ph_or_Cart_xyz_of_xx = rfm.xxCart
else:
print(
"Error: Can only convert ADM Cartesian or Spherical initial data to BSSN Curvilinear coords."
)
exit(1)
alphaSphorCart = sympify_integers__replace_rthph_or_Cartxyz(
alphaSphorCart, Sph_r_th_ph_or_Cart_xyz, r_th_ph_or_Cart_xyz_of_xx)
for i in range(DIM):
betaSphorCartU[i] = sympify_integers__replace_rthph_or_Cartxyz(
betaSphorCartU[i], Sph_r_th_ph_or_Cart_xyz,
r_th_ph_or_Cart_xyz_of_xx)
BSphorCartU[i] = sympify_integers__replace_rthph_or_Cartxyz(
BSphorCartU[i], Sph_r_th_ph_or_Cart_xyz, r_th_ph_or_Cart_xyz_of_xx)
for j in range(DIM):
gammaSphorCartDD[i][
j] = sympify_integers__replace_rthph_or_Cartxyz(
gammaSphorCartDD[i][j], Sph_r_th_ph_or_Cart_xyz,
r_th_ph_or_Cart_xyz_of_xx)
KSphorCartDD[i][j] = sympify_integers__replace_rthph_or_Cartxyz(
KSphorCartDD[i][j], Sph_r_th_ph_or_Cart_xyz,
r_th_ph_or_Cart_xyz_of_xx)
# Step 2: All ADM initial data quantities are now functions of xx0,xx1,xx2, but
# they are still in the Spherical or Cartesian basis. We can now directly apply
# Jacobian transformations to get them in the correct xx0,xx1,xx2 basis:
# alpha is a scalar, so no Jacobian transformation is necessary.
alpha = alphaSphorCart
Jac_dUSphorCart_dDrfmUD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
Jac_dUSphorCart_dDrfmUD[i][j] = sp.diff(
r_th_ph_or_Cart_xyz_of_xx[i], rfm.xx[j])
Jac_dUrfm_dDSphorCartUD, dummyDET = ixp.generic_matrix_inverter3x3(
Jac_dUSphorCart_dDrfmUD)
betaU = ixp.zerorank1()
BU = ixp.zerorank1()
gammaDD = ixp.zerorank2()
KDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
betaU[i] += Jac_dUrfm_dDSphorCartUD[i][j] * betaSphorCartU[j]
BU[i] += Jac_dUrfm_dDSphorCartUD[i][j] * BSphorCartU[j]
for k in range(DIM):
for l in range(DIM):
gammaDD[i][j] += Jac_dUSphorCart_dDrfmUD[k][
i] * Jac_dUSphorCart_dDrfmUD[l][j] * gammaSphorCartDD[
k][l]
KDD[i][j] += Jac_dUSphorCart_dDrfmUD[k][
i] * Jac_dUSphorCart_dDrfmUD[l][j] * KSphorCartDD[k][l]
# Step 3: All ADM quantities were input into this function in the Spherical or Cartesian
# basis, as functions of r,th,ph or x,y,z, respectively. In Steps 1 and 2 above,
# we converted them to the xx0,xx1,xx2 basis, and as functions of xx0,xx1,xx2.
# Here we convert ADM quantities to their BSSN Curvilinear counterparts:
# Step 3.1: Convert ADM $\gamma_{ij}$ to BSSN $\bar{\gamma}_{ij}$:
# We have (Eqs. 2 and 3 of [Ruchlin *et al.*](https://arxiv.org/pdf/1712.07658.pdf)):
# \bar{\gamma}_{i j} = \left(\frac{\bar{\gamma}}{\gamma}\right)^{1/3} \gamma_{ij}.
gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaDD)
gammabarDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
gammabarDD[i][j] = (rfm.detgammahat / gammaDET)**(sp.Rational(
1, 3)) * gammaDD[i][j]
# Step 3.2: Convert the extrinsic curvature $K_{ij}$ to the trace-free extrinsic
# curvature $\bar{A}_{ij}$, plus the trace of the extrinsic curvature $K$,
# where (Eq. 3 of [Baumgarte *et al.*](https://arxiv.org/pdf/1211.6632.pdf)):
# K = \gamma^{ij} K_{ij}, and
# \bar{A}_{ij} &= \left(\frac{\bar{\gamma}}{\gamma}\right)^{1/3} \left(K_{ij} - \frac{1}{3} \gamma_{ij} K \right)
trK = sp.sympify(0)
for i in range(DIM):
for j in range(DIM):
trK += gammaUU[i][j] * KDD[i][j]
AbarDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
AbarDD[i][j] = (rfm.detgammahat / gammaDET)**(sp.Rational(
1, 3)) * (KDD[i][j] - sp.Rational(1, 3) * gammaDD[i][j] * trK)
# Step 3.3: Define $\bar{\Lambda}^i$ (Eqs. 4 and 5 of [Baumgarte *et al.*](https://arxiv.org/pdf/1211.6632.pdf)):
# \bar{\Lambda}^i = \bar{\gamma}^{jk}\left(\bar{\Gamma}^i_{jk} - \hat{\Gamma}^i_{jk}\right).
gammabarUU, gammabarDET = ixp.symm_matrix_inverter3x3(gammabarDD)
# First compute \bar{\Gamma}^i_{jk}:
GammabarUDD = ixp.zerorank3()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
GammabarUDD[i][j][k] += sp.Rational(
1, 2) * gammabarUU[i][l] * (
sp.diff(gammabarDD[l][j], rfm.xx[k]) +
sp.diff(gammabarDD[l][k], rfm.xx[j]) -
sp.diff(gammabarDD[j][k], rfm.xx[l]))
# Next evaluate \bar{\Lambda}^i, based on GammabarUDD above and GammahatUDD
# (from the reference metric):
LambdabarU = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
LambdabarU[i] += gammabarUU[j][k] * (GammabarUDD[i][j][k] -
rfm.GammahatUDD[i][j][k])
# Step 3.4: Set the conformal factor variable $\texttt{cf}$, which is set
# by the "BSSN_quantities::ConformalFactor" parameter. For example if
# "ConformalFactor" is set to "phi", we can use Eq. 3 of
# [Ruchlin *et al.*](https://arxiv.org/pdf/1712.07658.pdf),
# which in arbitrary coordinates is written:
# \phi = \frac{1}{12} \log\left(\frac{\gamma}{\bar{\gamma}}\right).
# Alternatively if "BSSN_quantities::ConformalFactor" is set to "chi", then
# \chi = e^{-4 \phi} = \exp\left(-4 \frac{1}{12} \left(\frac{\gamma}{\bar{\gamma}}\right)\right)
# = \exp\left(-\frac{1}{3} \log\left(\frac{\gamma}{\bar{\gamma}}\right)\right) = \left(\frac{\gamma}{\bar{\gamma}}\right)^{-1/3}.
#
# Finally if "BSSN_quantities::ConformalFactor" is set to "W", then
# W = e^{-2 \phi} = \exp\left(-2 \frac{1}{12} \log\left(\frac{\gamma}{\bar{\gamma}}\right)\right) =
# \exp\left(-\frac{1}{6} \log\left(\frac{\gamma}{\bar{\gamma}}\right)\right) =
# \left(\frac{\gamma}{\bar{\gamma}}\right)^{-1/6}.
cf = sp.sympify(0)
if par.parval_from_str("ConformalFactor") == "phi":
cf = sp.Rational(1, 12) * sp.log(gammaDET / gammabarDET)
elif par.parval_from_str("ConformalFactor") == "chi":
cf = (gammaDET / gammabarDET)**(-sp.Rational(1, 3))
elif par.parval_from_str("ConformalFactor") == "W":
cf = (gammaDET / gammabarDET)**(-sp.Rational(1, 6))
else:
print("Error ConformalFactor type = \"" +
par.parval_from_str("ConformalFactor") + "\" unknown.")
exit(1)
# Step 4: Rescale tensorial quantities according to the prescription described in
# the [BSSN in curvilinear coordinates tutorial module](Tutorial-BSSNCurvilinear.ipynb)
# (also [Ruchlin *et al.*](https://arxiv.org/pdf/1712.07658.pdf)):
#
# h_{ij} &= (\bar{\gamma}_{ij} - \hat{\gamma}_{ij})/\text{ReDD[i][j]}\\
# a_{ij} &= \bar{A}_{ij}/\text{ReDD[i][j]}\\
# \lambda^i &= \bar{\Lambda}^i/\text{ReU[i]}\\
# \mathcal{V}^i &= \beta^i/\text{ReU[i]}\\
# \mathcal{B}^i &= B^i/\text{ReU[i]}\\
hDD = ixp.zerorank2()
aDD = ixp.zerorank2()
lambdaU = ixp.zerorank1()
vetU = ixp.zerorank1()
betU = ixp.zerorank1()
for i in range(DIM):
lambdaU[i] = LambdabarU[i] / rfm.ReU[i]
vetU[i] = betaU[i] / rfm.ReU[i]
betU[i] = BU[i] / rfm.ReU[i]
for j in range(DIM):
hDD[i][j] = (gammabarDD[i][j] - rfm.ghatDD[i][j]) / rfm.ReDD[i][j]
aDD[i][j] = AbarDD[i][j] / rfm.ReDD[i][j]
#print(sp.mathematica_code(hDD[0][0]))
# Step 5: Return the BSSN Curvilinear variables in the desired xx0,xx1,xx2
# basis, and as functions of the consistent xx0,xx1,xx2 coordinates.
return cf, hDD, lambdaU, aDD, trK, alpha, vetU, betU
def Psi4_tetradsv2():
global l4U, n4U, mre4U, mim4U
# Step 1.c: Check if tetrad choice is implemented:
if par.parval_from_str(thismodule + "::TetradChoice") != "QuasiKinnersley":
print("ERROR: " + thismodule + "::TetradChoice = " +
par.parval_from_str("TetradChoice") + " currently unsupported!")
exit(1)
# Step 1.d: Given the chosen coordinate system, set up
# corresponding reference metric and needed
# reference metric quantities
# The following function call sets up the reference metric
# and related quantities, including rescaling matrices ReDD,
# ReU, and hatted quantities.
rfm.reference_metric()
# Step 1.e: Set spatial dimension (must be 3 for BSSN, as BSSN is
# a 3+1-dimensional decomposition of the general
# relativistic field equations)
DIM = 3
# Step 1.f: Import all ADM quantities as written in terms of BSSN quantities
import BSSN.ADM_in_terms_of_BSSN as AB
AB.ADM_in_terms_of_BSSN()
# Step 2.a: Declare the Cartesian x,y,z as input parameters
# and v_1^a, v_2^a, and v_3^a tetrads,
# as well as detgamma and gammaUU from
# BSSN.ADM_in_terms_of_BSSN
x, y, z = par.Cparameters("REAL", thismodule, ["x", "y", "z"])
v1UCart = ixp.zerorank1()
v2UCart = ixp.zerorank1()
# detgamma = AB.detgamma
# gammaUU = AB.gammaUU
# Step 2.b: Define v1U and v2U
v1UCart = [-y, x, sp.sympify(0)]
v2UCart = [x, y, z]
# Step 2.c: Construct the Jacobian d x_Cart^i / d xx^j
Jac_dUCart_dDrfmUD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
Jac_dUCart_dDrfmUD[i][j] = sp.diff(rfm.xxCart[i], rfm.xx[j])
# Step 2.d: Invert above Jacobian to get needed d xx^j / d x_Cart^i
Jac_dUrfm_dDCartUD, dummyDET = ixp.generic_matrix_inverter3x3(
Jac_dUCart_dDrfmUD)
# Step 2.e: Transform gammaDD to Cartesian basis:
gammaCartDD = ixp.zerorank2()
gammaDD = AB.gammaDD
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
gammaCartDD[i][j] += Jac_dUrfm_dDCartUD[k][
i] * Jac_dUrfm_dDCartUD[l][j] * gammaDD[k][l]
gammaCartUU, detgammaCart = ixp.symm_matrix_inverter3x3(gammaCartDD)
# Step 2.e: Transform v1U and v2U from the Cartesian to the xx^i basis
v1U = ixp.zerorank1()
v2U = ixp.zerorank1()
for i in range(DIM):
v1U[i] = v1UCart[i]
v2U[i] = v2UCart[i]
# for i in range(DIM):
# for j in range(DIM):
# v1U[i] += Jac_dUrfm_dDCartUD[i][j]*v1UCart[j]
# v2U[i] += Jac_dUrfm_dDCartUD[i][j]*v2UCart[j]
# Step 2.f: Define the rank-3 version of the Levi-Civita symbol. Amongst
# other uses, this is needed for the construction of the approximate
# quasi-Kinnersley tetrad.
def define_LeviCivitaSymbol_rank3(DIM=-1):
if DIM == -1:
DIM = par.parval_from_str("DIM")
LeviCivitaSymbol = ixp.zerorank3()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
# From https://codegolf.stackexchange.com/questions/160359/levi-civita-symbol :
LeviCivitaSymbol[i][j][k] = (i - j) * (j - k) * (k - i) / 2
return LeviCivitaSymbol
# Step 2.g: Define v3U
v3U = ixp.zerorank1()
LeviCivitaSymbolDDD = define_LeviCivitaSymbol_rank3(DIM=3)
for a in range(DIM):
for b in range(DIM):
for c in range(DIM):
for d in range(DIM):
v3U[a] += sp.sqrt(detgammaCart) * gammaCartUU[a][
d] * LeviCivitaSymbolDDD[d][b][c] * v1U[b] * v2U[c]
# Step 2.h: Define omega_{ij}
omegaDD = ixp.zerorank2()
# Step 2.i: Define e^a_i. Note that:
# omegaDD[0][0] = \omega_{11} above;
# omegaDD[1][1] = \omega_{22} above, etc.
e1U = ixp.zerorank1()
e2U = ixp.zerorank1()
e3U = ixp.zerorank1()
update_omega(omegaDD, v1U, v2U, v3U, gammaCartDD)
for a in range(DIM):
e1U[a] = v1U[a] / sp.sqrt(omegaDD[0][0])
update_omega(omegaDD, e1U, v2U, v3U, gammaCartDD)
for a in range(DIM):
e2U[a] = (v2U[a] - omegaDD[0][1] * e1U[a]) / sp.sqrt(omegaDD[1][1])
update_omega(omegaDD, e1U, e2U, v3U, gammaCartDD)
for a in range(DIM):
e3U[a] = (v3U[a] - omegaDD[0][2] * e1U[a] -
omegaDD[1][2] * e2U[a]) / sp.sqrt(omegaDD[2][2])
# Step 2.j: Construct l^mu, n^mu, and m^mu, based on r^mu, theta^mu, phi^mu, and u^mu:
rCart4U = ixp.zerorank1(DIM=4)
thetaCart4U = ixp.zerorank1(DIM=4)
phiCart4U = ixp.zerorank1(DIM=4)
for a in range(DIM):
rCart4U[a + 1] = e2U[a]
thetaCart4U[a + 1] = e3U[a]
phiCart4U[a + 1] = e1U[a]
r4U = ixp.zerorank1(DIM=4)
theta4U = ixp.zerorank1(DIM=4)
phi4U = ixp.zerorank1(DIM=4)
for a in range(DIM):
for b in range(DIM):
r4U[a + 1] += Jac_dUrfm_dDCartUD[a][b] * rCart4U[b + 1]
theta4U[a + 1] += Jac_dUrfm_dDCartUD[a][b] * thetaCart4U[b + 1]
phi4U[a + 1] += Jac_dUrfm_dDCartUD[a][b] * phiCart4U[b + 1]
u4U = ixp.zerorank1(DIM=4)
# FIXME? assumes alpha=1, beta^i = 0
u4U[0] = 1
l4U = ixp.zerorank1(DIM=4)
n4U = ixp.zerorank1(DIM=4)
mre4U = ixp.zerorank1(DIM=4)
mim4U = ixp.zerorank1(DIM=4)
isqrt2 = 1 / sp.sqrt(2)
for mu in range(4):
l4U[mu] = isqrt2 * (u4U[mu] + r4U[mu])
n4U[mu] = isqrt2 * (u4U[mu] - r4U[mu])
mre4U[mu] = isqrt2 * theta4U[mu]
mim4U[mu] = isqrt2 * phi4U[mu]
def GiRaFFE_NRPy_C2P(StildeD,BU,gammaDD,betaU,alpha):
GRHD.compute_sqrtgammaDET(gammaDD)
gammaUU,unusedgammadet = ixp.symm_matrix_inverter3x3(gammaDD)
BtildeU = ixp.zerorank1()
for i in range(3):
# \tilde{B}^i = B^i \sqrt{\gamma}
BtildeU[i] = GRHD.sqrtgammaDET*BU[i]
BtildeD = ixp.zerorank1()
for i in range(3):
for j in range(3):
BtildeD[j] += gammaDD[i][j]*BtildeU[i]
Btilde2 = sp.sympify(0)
for i in range(3):
Btilde2 += BtildeU[i]*BtildeD[i]
global outStildeD
outStildeD = StildeD
# Then, enforce the orthogonality:
if par.parval_from_str("enforce_orthogonality_StildeD_BtildeU"):
StimesB = sp.sympify(0)
for i in range(3):
StimesB += StildeD[i]*BtildeU[i]
for i in range(3):
# {\tilde S}_i = {\tilde S}_i - ({\tilde S}_j {\tilde B}^j) {\tilde B}_i/{\tilde B}^2
outStildeD[i] -= StimesB*BtildeD[i]/Btilde2
# Calculate \tilde{S}^2:
Stilde2 = sp.sympify(0)
for i in range(3):
for j in range(3):
Stilde2 += gammaUU[i][j]*outStildeD[i]*outStildeD[j]
# First we need to compute the factor f:
# f = \sqrt{(1-\Gamma_{\max}^{-2}){\tilde B}^4/(16 \pi^2 \gamma {\tilde S}^2)}
speed_limit_factor = sp.sqrt((sp.sympify(1)-GAMMA_SPEED_LIMIT**(-2.0))*Btilde2*Btilde2*sp.Rational(1,16)/\
(M_PI*M_PI*GRHD.sqrtgammaDET*GRHD.sqrtgammaDET*Stilde2))
import Min_Max_and_Piecewise_Expressions as noif
# Calculate B^2
B2 = sp.sympify(0)
for i in range(3):
for j in range(3):
B2 += gammaDD[i][j]*BU[i]*BU[j]
# Enforce the speed limit on StildeD:
if par.parval_from_str("enforce_speed_limit_StildeD"):
for i in range(3):
outStildeD[i] *= noif.min_noif(sp.sympify(1),speed_limit_factor)
global ValenciavU
ValenciavU = ixp.zerorank1()
# Recompute 3-velocity:
for i in range(3):
for j in range(3):
# \bar{v}^i = 4 \pi \gamma^{ij} {\tilde S}_j / (\sqrt{\gamma} B^2)
ValenciavU[i] += sp.sympify(4)*M_PI*gammaUU[i][j]*outStildeD[j]/(GRHD.sqrtgammaDET*B2)
# This number determines how far away (in grid points) we will apply the fix.
grid_points_from_z_plane = par.Cparameters("REAL",thismodule,"grid_points_from_z_plane",4.0)
if par.parval_from_str("enforce_current_sheet_prescription"):
# Calculate the drift velocity
driftvU = ixp.zerorank1()
for i in range(3):
driftvU[i] = alpha*ValenciavU[i] - betaU[i]
# The direct approach, used by the original GiRaFFE:
# v^z = -(\gamma_{xz} v^x + \gamma_{yz} v^y) / \gamma_{zz}
newdriftvU2 = -(gammaDD[0][2]*driftvU[0] + gammaDD[1][2]*driftvU[1])/gammaDD[2][2]
# Now that we have the z component, it's time to substitute its Valencia form in.
# Remember, we only do this if abs(z) < (k+0.01)*dz. Note that we add 0.01; this helps
# avoid floating point errors and division by zero. This is the same as abs(z) - (k+0.01)*dz<0
coord = nrpyAbs(rfm.xx[2])
bound =(grid_points_from_z_plane+sp.Rational(1,100))*gri.dxx[2]
ValenciavU[2] = noif.coord_leq_bound(coord,bound)*(newdriftvU2+betaU[2])/alpha \
+ noif.coord_greater_bound(coord,bound)*ValenciavU[2]
def WeylScalars_Cartesian():
# Step 3.a: Set spatial dimension (must be 3 for BSSN)
DIM = 3
par.set_parval_from_str("grid::DIM", DIM)
# Step 3.b: declare the additional gridfunctions (i.e., functions whose values are declared
# at every grid point, either inside or outside of our SymPy expressions) needed
# for this thorn:
# * the physical metric $\gamma_{ij}$,
# * the extrinsic curvature $K_{ij}$,
# * the real and imaginary components of $\psi_4$, and
# * the Weyl curvature invariants:
gammaDD = ixp.register_gridfunctions_for_single_rank2(
"AUX", "gammaDD", "sym01") # The AUX or EVOL designation is *not*
# used in diagnostic modules.
kDD = ixp.register_gridfunctions_for_single_rank2("AUX", "kDD", "sym01")
x, y, z = gri.register_gridfunctions("AUX", ["x", "y", "z"])
global psi4r, psi4i, psi3r, psi3i, psi2r, psi2i, psi1r, psi1i, psi0r, psi0i
psi4r, psi4i, psi3r, psi3i, psi2r, psi2i, psi1r, psi1i, psi0r, psi0i = gri.register_gridfunctions(
"AUX", [
"psi4r", "psi4i", "psi3r", "psi3i", "psi2r", "psi2i", "psi1r",
"psi1i", "psi0r", "psi0i"
])
# Step 4: Set which tetrad is used; at the moment, only one supported option
# The tetrad depends in general on the inverse 3-metric gammaUU[i][j]=\gamma^{ij}
# and the determinant of the 3-metric (detgamma), which are defined in
# the following line of code from gammaDD[i][j]=\gamma_{ij}.
tmpgammaUU, detgamma = ixp.symm_matrix_inverter3x3(gammaDD)
detgamma = sp.simplify(detgamma)
gammaUU = ixp.zerorank2()
for i in range(3):
for j in range(3):
gammaUU[i][j] = sp.simplify(tmpgammaUU[i][j])
if par.parval_from_str("WeylScal4NRPy.WeylScalars_Cartesian::TetradChoice"
) == "Approx_QuasiKinnersley":
# Eqs 5.6 in https://arxiv.org/pdf/gr-qc/0104063.pdf
xmoved = x # - xorig
ymoved = y # - yorig
zmoved = z # - zorig
# Step 5.a: Choose 3 orthogonal vectors. Here, we choose one in the azimuthal
# direction, one in the radial direction, and the cross product of the two.
# Eqs 5.7
v1U = ixp.zerorank1()
v2U = ixp.zerorank1()
v3U = ixp.zerorank1()
v1U[0] = -ymoved
v1U[1] = xmoved # + offset
v1U[2] = sp.sympify(0)
v2U[0] = xmoved # + offset
v2U[1] = ymoved
v2U[2] = zmoved
LeviCivitaSymbol_rank3 = ixp.LeviCivitaSymbol_dim3_rank3()
for a in range(DIM):
for b in range(DIM):
for c in range(DIM):
for d in range(DIM):
v3U[a] += sp.sqrt(
detgamma) * gammaUU[a][d] * LeviCivitaSymbol_rank3[
d][b][c] * v1U[b] * v2U[c]
for a in range(DIM):
v3U[a] = sp.simplify(v3U[a])
# Step 5.b: Gram-Schmidt orthonormalization of the vectors.
# The w_i^a vectors here are used to temporarily hold values on the way to the final vectors e_i^a
# e_1^a &= \frac{v_1^a}{\omega_{11}}
# e_2^a &= \frac{v_2^a - \omega_{12} e_1^a}{\omega_{22}}
# e_3^a &= \frac{v_3^a - \omega_{13} e_1^a - \omega_{23} e_2^a}{\omega_{33}},
# Normalize the first vector
w1U = ixp.zerorank1()
for a in range(DIM):
w1U[a] = v1U[a]
omega11 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega11 += w1U[a] * w1U[b] * gammaDD[a][b]
e1U = ixp.zerorank1()
for a in range(DIM):
e1U[a] = w1U[a] / sp.sqrt(omega11)
# Subtract off the portion of the first vector along the second, then normalize
omega12 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega12 += e1U[a] * v2U[b] * gammaDD[a][b]
w2U = ixp.zerorank1()
for a in range(DIM):
w2U[a] = v2U[a] - omega12 * e1U[a]
omega22 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega22 += w2U[a] * w2U[b] * gammaDD[a][b]
e2U = ixp.zerorank1()
for a in range(DIM):
e2U[a] = w2U[a] / sp.sqrt(omega22)
# Subtract off the portion of the first and second vectors along the third, then normalize
omega13 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega13 += e1U[a] * v3U[b] * gammaDD[a][b]
omega23 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega23 += e2U[a] * v3U[b] * gammaDD[a][b]
w3U = ixp.zerorank1()
for a in range(DIM):
w3U[a] = v3U[a] - omega13 * e1U[a] - omega23 * e2U[a]
omega33 = sp.sympify(0)
for a in range(DIM):
for b in range(DIM):
omega33 += w3U[a] * w3U[b] * gammaDD[a][b]
e3U = ixp.zerorank1()
for a in range(DIM):
e3U[a] = w3U[a] / sp.sqrt(omega33)
# Step 5.c: Construct the tetrad itself.
# Eqs. 5.6:
# l^a &= \frac{1}{\sqrt{2}} e_2^a \\
# n^a &= -\frac{1}{\sqrt{2}} e_2^a \\
# m^a &= \frac{1}{\sqrt{2}} (e_3^a + i e_1^a) \\
# \overset{*}{m}{}^a &= \frac{1}{\sqrt{2}} (e_3^a - i e_1^a)
isqrt2 = 1 / sp.sqrt(2)
ltetU = ixp.zerorank1()
ntetU = ixp.zerorank1()
# mtetU = ixp.zerorank1()
# mtetccU = ixp.zerorank1()
remtetU = ixp.zerorank1(
) # SymPy did not like trying to take the real/imaginary parts of such a
immtetU = ixp.zerorank1(
) # complicated expression, so we do it ourselves.
for i in range(DIM):
ltetU[i] = isqrt2 * e2U[i]
ntetU[i] = -isqrt2 * e2U[i]
remtetU[i] = isqrt2 * e3U[i]
immtetU[i] = isqrt2 * e1U[i]
nn = isqrt2
else:
print("Error: TetradChoice == " + par.parval_from_str("TetradChoice") +
" unsupported!")
sys.exit(1)
# Step 5: Declare and construct the second derivative of the metric.
gammaDD_dD = ixp.declarerank3("gammaDD_dD", "sym01")
# Define the Christoffel symbols
GammaUDD = ixp.zerorank3(DIM)
for i in range(DIM):
for k in range(DIM):
for l in range(DIM):
for m in range(DIM):
GammaUDD[i][k][l] += (sp.Rational(1, 2)) * gammaUU[i][m] * \
(gammaDD_dD[m][k][l] + gammaDD_dD[m][l][k] - gammaDD_dD[k][l][m])
# Step 6.a: Declare and construct the Riemann curvature tensor:
# R_{abcd} = \frac{1}{2} (\gamma_{ad,cb}+\gamma_{bc,da}-\gamma_{ac,bd}-\gamma_{bd,ac})
# + \gamma_{je} \Gamma^{j}_{bc}\Gamma^{e}_{ad} - \gamma_{je} \Gamma^{j}_{bd} \Gamma^{e}_{ac}
gammaDD_dDD = ixp.declarerank4("gammaDD_dDD", "sym01_sym23")
RiemannDDDD = ixp.zerorank4()
for a in range(DIM):
for b in range(DIM):
for c in range(DIM):
for d in range(DIM):
RiemannDDDD[a][b][c][d] = (gammaDD_dDD[a][d][c][b] + \
gammaDD_dDD[b][c][d][a] - \
gammaDD_dDD[a][c][b][d] - \
gammaDD_dDD[b][d][a][c]) / 2
for e in range(DIM):
for j in range(DIM):
RiemannDDDD[a][b][c][d] += gammaDD[j][e] * GammaUDD[j][b][c] * GammaUDD[e][a][d] - \
gammaDD[j][e] * GammaUDD[j][b][d] * GammaUDD[e][a][c]
# Step 6.b: We also need the extrinsic curvature tensor $K_{ij}$.
# In Cartesian coordinates, we already made the components gridfunctions.
# We will, however, need to calculate the trace of K seperately:
trK = sp.sympify(0)
for i in range(DIM):
for j in range(DIM):
trK += gammaUU[i][j] * kDD[i][j]
# Step 7: Build the formula for \psi_4.
# Gauss equation: involving the Riemann tensor and extrinsic curvature.
# GaussDDDD[i][j][k][l] =& R_{ijkl} + 2K_{i[k}K_{l]j}
GaussDDDD = ixp.zerorank4()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
GaussDDDD[i][j][k][l] = RiemannDDDD[i][j][k][
l] + kDD[i][k] * kDD[l][j] - kDD[i][l] * kDD[k][j]
# Codazzi equation: involving partial derivatives of the extrinsic curvature.
# We will first need to declare derivatives of kDD
# CodazziDDD[j][k][l] =& -2 (K_{j[k,l]} + \Gamma^p_{j[k} K_{l]p})
kDD_dD = ixp.declarerank3("kDD_dD", "sym01")
CodazziDDD = ixp.zerorank3()
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
CodazziDDD[j][k][l] = kDD_dD[j][l][k] - kDD_dD[j][k][l]
for p in range(DIM):
CodazziDDD[j][k][l] += GammaUDD[p][j][l] * kDD[k][
p] - GammaUDD[p][j][k] * kDD[l][p]
# Another piece. While not associated with any particular equation,
# this is still useful for organizational purposes.
# RojoDD[j][l]} = & R_{jl} - K_{jp} K^p_l + KK_{jl} \\
# = & \gamma^{pd} R_{jpld} - K_{jp} K^p_l + KK_{jl}
RojoDD = ixp.zerorank2()
for j in range(DIM):
for l in range(DIM):
RojoDD[j][l] = trK * kDD[j][l]
for p in range(DIM):
for d in range(DIM):
RojoDD[j][l] += gammaUU[p][d] * RiemannDDDD[j][p][l][
d] - kDD[j][p] * gammaUU[p][d] * kDD[d][l]
# Now we can calculate $\psi_4$ itself! We assume l^0 = n^0 = \frac{1}{\sqrt{2}}
# and m^0 = \overset{*}{m}{}^0 = 0 to simplify these equations.
# We calculate the Weyl scalars as defined in https://arxiv.org/abs/gr-qc/0104063
# In terms of the above-defined quantites, the psis are defined as:
# \psi_4 =&\ (\text{GaussDDDD[i][j][k][l]}) n^i \overset{*}{m}{}^j n^k \overset{*}{m}{}^l \\
# &+2 (\text{CodazziDDD[j][k][l]}) n^{0} \overset{*}{m}{}^{j} n^k \overset{*}{m}{}^l \\
# &+ (\text{RojoDD[j][l]}) n^{0} \overset{*}{m}{}^{j} n^{0} \overset{*}{m}{}^{l}.
# \psi_3 =&\ (\text{GaussDDDD[i][j][k][l]}) l^i n^j \overset{*}{m}{}^k n^l \\
# &+ (\text{CodazziDDD[j][k][l]}) (l^{0} n^{j} \overset{*}{m}{}^k n^l - l^{j} n^{0} \overset{*}{m}{}^k n^l - l^k n^j\overset{*}{m}{}^l n^0) \\
# &- (\text{RojoDD[j][l]}) l^{0} n^{j} \overset{*}{m}{}^l n^0 - l^{j} n^{0} \overset{*}{m}{}^l n^0 \\
# \psi_2 =&\ (\text{GaussDDDD[i][j][k][l]}) l^i m^j \overset{*}{m}{}^k n^l \\
# &+ (\text{CodazziDDD[j][k][l]}) (l^{0} m^{j} \overset{*}{m}{}^k n^l - l^{j} m^{0} \overset{*}{m}{}^k n^l - l^k m^l \overset{*}{m}{}^l n^0) \\
# &- (\text{RojoDD[j][l]}) l^0 m^j \overset{*}{m}{}^l n^0 \\
# \psi_1 =&\ (\text{GaussDDDD[i][j][k][l]}) n^i l^j m^k l^l \\
# &+ (\text{CodazziDDD[j][k][l]}) (n^{0} l^{j} m^k l^l - n^{j} l^{0} m^k l^l - n^k l^l m^j l^0) \\
# &- (\text{RojoDD[j][l]}) (n^{0} l^{j} m^l l^0 - n^{j} l^{0} m^l l^0) \\
# \psi_0 =&\ (\text{GaussDDDD[i][j][k][l]}) l^i m^j l^k m^l \\
# &+2 (\text{CodazziDDD[j][k][l]}) (l^0 m^j l^k m^l + l^k m^l l^0 m^j) \\
# &+ (\text{RojoDD[j][l]}) l^0 m^j l^0 m^j. \\
psi4r = sp.sympify(0)
psi4i = sp.sympify(0)
psi3r = sp.sympify(0)
psi3i = sp.sympify(0)
psi2r = sp.sympify(0)
psi2i = sp.sympify(0)
psi1r = sp.sympify(0)
psi1i = sp.sympify(0)
psi0r = sp.sympify(0)
psi0i = sp.sympify(0)
for l in range(DIM):
for j in range(DIM):
psi4r += RojoDD[j][l] * nn * nn * (remtetU[j] * remtetU[l] -
immtetU[j] * immtetU[l])
psi4i += RojoDD[j][l] * nn * nn * (-remtetU[j] * immtetU[l] -
immtetU[j] * remtetU[l])
psi3r += -RojoDD[j][l] * nn * nn * (ntetU[j] -
ltetU[j]) * remtetU[l]
psi3i += RojoDD[j][l] * nn * nn * (ntetU[j] -
ltetU[j]) * immtetU[l]
psi2r += -RojoDD[j][l] * nn * nn * (remtetU[l] * remtetU[j] +
immtetU[j] * immtetU[l])
psi2i += -RojoDD[j][l] * nn * nn * (immtetU[l] * remtetU[j] -
remtetU[j] * immtetU[l])
psi1r += RojoDD[j][l] * nn * nn * (ntetU[j] * remtetU[l] -
ltetU[j] * remtetU[l])
psi1i += RojoDD[j][l] * nn * nn * (ntetU[j] * immtetU[l] -
ltetU[j] * immtetU[l])
psi0r += RojoDD[j][l] * nn * nn * (remtetU[j] * remtetU[l] -
immtetU[j] * immtetU[l])
psi0i += RojoDD[j][l] * nn * nn * (remtetU[j] * immtetU[l] +
immtetU[j] * remtetU[l])
for l in range(DIM):
for j in range(DIM):
for k in range(DIM):
psi4r += 2 * CodazziDDD[j][k][l] * ntetU[k] * nn * (
remtetU[j] * remtetU[l] - immtetU[j] * immtetU[l])
psi4i += 2 * CodazziDDD[j][k][l] * ntetU[k] * nn * (
-remtetU[j] * immtetU[l] - immtetU[j] * remtetU[l])
psi3r += 1 * CodazziDDD[j][k][l] * nn * (
(ntetU[j] - ltetU[j]) * remtetU[k] * ntetU[l] -
remtetU[j] * ltetU[k] * ntetU[l])
psi3i += -1 * CodazziDDD[j][k][l] * nn * (
(ntetU[j] - ltetU[j]) * immtetU[k] * ntetU[l] -
immtetU[j] * ltetU[k] * ntetU[l])
psi2r += 1 * CodazziDDD[j][k][l] * nn * (
ntetU[l] *
(remtetU[j] * remtetU[k] + immtetU[j] * immtetU[k]) -
ltetU[k] *
(remtetU[j] * remtetU[l] + immtetU[j] * immtetU[l]))
psi2i += 1 * CodazziDDD[j][k][l] * nn * (
ntetU[l] *
(immtetU[j] * remtetU[k] - remtetU[j] * immtetU[k]) -
ltetU[k] *
(remtetU[j] * immtetU[l] - immtetU[j] * remtetU[l]))
psi1r += 1 * CodazziDDD[j][k][l] * nn * (
ltetU[j] * remtetU[k] * ltetU[l] - remtetU[j] * ntetU[k] *
ltetU[l] - ntetU[j] * remtetU[k] * ltetU[l])
psi1i += 1 * CodazziDDD[j][k][l] * nn * (
ltetU[j] * immtetU[k] * ltetU[l] - immtetU[j] * ntetU[k] *
ltetU[l] - ntetU[j] * immtetU[k] * ltetU[l])
psi0r += 2 * CodazziDDD[j][k][l] * nn * ltetU[k] * (
remtetU[j] * remtetU[l] - immtetU[j] * immtetU[l])
psi0i += 2 * CodazziDDD[j][k][l] * nn * ltetU[k] * (
remtetU[j] * immtetU[l] + immtetU[j] * remtetU[l])
for l in range(DIM):
for j in range(DIM):
for k in range(DIM):
for i in range(DIM):
psi4r += GaussDDDD[i][j][k][l] * ntetU[i] * ntetU[k] * (
remtetU[j] * remtetU[l] - immtetU[j] * immtetU[l])
psi4i += GaussDDDD[i][j][k][l] * ntetU[i] * ntetU[k] * (
-remtetU[j] * immtetU[l] - immtetU[j] * remtetU[l])
psi3r += GaussDDDD[i][j][k][l] * ltetU[i] * ntetU[
j] * remtetU[k] * ntetU[l]
psi3i += -GaussDDDD[i][j][k][l] * ltetU[i] * ntetU[
j] * immtetU[k] * ntetU[l]
psi2r += GaussDDDD[i][j][k][l] * ltetU[i] * ntetU[l] * (
remtetU[j] * remtetU[k] + immtetU[j] * immtetU[k])
psi2i += GaussDDDD[i][j][k][l] * ltetU[i] * ntetU[l] * (
immtetU[j] * remtetU[k] - remtetU[j] * immtetU[k])
psi1r += GaussDDDD[i][j][k][l] * ntetU[i] * ltetU[
j] * remtetU[k] * ltetU[l]
psi1i += GaussDDDD[i][j][k][l] * ntetU[i] * ltetU[
j] * immtetU[k] * ltetU[l]
psi0r += GaussDDDD[i][j][k][l] * ltetU[i] * ltetU[k] * (
remtetU[j] * remtetU[l] - immtetU[j] * immtetU[l])
psi0i += GaussDDDD[i][j][k][l] * ltetU[i] * ltetU[k] * (
remtetU[j] * immtetU[l] + immtetU[j] * remtetU[l])
def stress_energy_source_terms_ito_T4UU_and_ADM_or_BSSN_metricvars(
inputvars, custom_T4UU=None):
# Step 1: Check if rfm.reference_metric() already called. If not, BSSN
# quantities are not yet defined, so cannot proceed!
if rfm.have_already_called_reference_metric_function == False:
print(
"BSSN_source_terms_ito_T4UU(): Must call reference_metric() first!"
)
sys.exit(1)
# Step 2.a: Define gamma4DD[mu][nu] = g_{mu nu} + n_{mu} n_{nu}
alpha = sp.symbols("alpha", real=True)
zero = sp.sympify(0)
n4D = [-alpha, zero, zero, zero]
AB4m.g4DD_ito_BSSN_or_ADM(inputvars)
gamma4DD = ixp.zerorank2(DIM=4)
for mu in range(4):
for nu in range(4):
gamma4DD[mu][nu] = AB4m.g4DD[mu][nu] + n4D[mu] * n4D[nu]
# Step 2.b: If expression for components of T4UU not given, declare T4UU here
if custom_T4UU == None:
T4UU = ixp.declarerank2("T4UU", "sym01", DIM=4)
else:
T4UU = custom_T4UU
# Step 2.c: Define BSSN source terms
global SDD, SD, S, rho
# Step 2.c.i: S_{ij} = gamma_{i mu} gamma_{j nu} T^{mu nu}
SDD = ixp.zerorank2()
for i in range(3):
for j in range(3):
for mu in range(4):
for nu in range(4):
SDD[i][j] += gamma4DD[i + 1][mu] * gamma4DD[
j + 1][nu] * T4UU[mu][nu]
# Step 2.c.ii: S_{i} = -gamma_{i mu} n_{nu} T^{mu nu}
SD = ixp.zerorank1()
for i in range(3):
for mu in range(4):
for nu in range(4):
SD[i] += -gamma4DD[i + 1][mu] * n4D[nu] * T4UU[mu][nu]
# Step 2.c.iii: S = gamma^{ij} S_{ij}
if inputvars == "ADM":
gammaDD = ixp.declarerank2("gammaDD", "sym01")
gammaUU, dummydet = ixp.symm_matrix_inverter3x3(gammaDD) # Set gammaUU
elif inputvars == "BSSN":
import BSSN.ADM_in_terms_of_BSSN as AitoB # NRPy+: ADM quantities in terms of BSSN quantities
AitoB.ADM_in_terms_of_BSSN()
gammaUU = AitoB.gammaUU
S = zero
for i in range(3):
for j in range(3):
S += gammaUU[i][j] * SDD[i][j]
# Step 2.c.iv: rho = n_{mu} n_{nu} T^{mu nu}
rho = zero
for mu in range(4):
for nu in range(4):
rho += n4D[mu] * n4D[nu] * T4UU[mu][nu]
return SDD, SD, S, rho
def compute_sqrtgammaDET(gammaDD):
global sqrtgammaDET
_gammaUU, gammaDET = ixp.symm_matrix_inverter3x3(
gammaDD) # _gammaUU unused.
sqrtgammaDET = sp.sqrt(gammaDET)
def Tmunu_Numerical_Spherical_or_Cartesian_to_BSSNCurvilinear(
CoordType_in, Tmunu_input_function_name, pointer_to_ID_inputs=False):
# The ADM & BSSN formalisms only work in 3D; they are 3+1 decompositions of Einstein's equations.
# To implement axisymmetry or spherical symmetry, simply set all spatial derivatives in
# the relevant angular directions to zero; DO NOT SET DIM TO ANYTHING BUT 3.
# Step 0: Set spatial dimension (must be 3 for BSSN)
DIM = 3
# Step 1: Define the input variables: the 4D stress-energy tensor, and the ADM 3-metric, lapse, & shift:
T4SphorCartUU = ixp.declarerank2("T4SphorCartUU", "sym01", DIM=4)
gammaSphorCartDD = ixp.declarerank2("gammaSphorCartDD", "sym01")
alphaSphorCart = sp.symbols("alphaSphorCart")
betaSphorCartU = ixp.declarerank1("betaSphorCartU")
# Step 2: All Tmunu initial data quantities are functions of xx0,xx1,xx2, but
# in the Spherical or Cartesian basis.
# We first define the BSSN stress-energy source terms in the Spherical
# or Cartesian basis, respectively.
# To get \gamma_{\mu \nu} = gammabar4DD[mu][nu], we'll need to construct the 4-metric, using Eq. 2.122 in B&S:
# S_{ij} = \gamma_{i \mu} \gamma_{j \nu} T^{\mu \nu}
# S_{i} = -\gamma_{i\mu} n_\nu T^{\mu\nu}
# S = \gamma^{ij} S_{ij}
# rho = n_\mu n_\nu T^{\mu\nu},
# where
# \gamma_{\mu\nu} = g_{\mu\nu} + n_\mu n_\nu
# and
# n_mu = {-\alpha,0,0,0},
# Step 2.1: Construct the 4-metric based on the input ADM quantities.
# This is provided by Eq 4.47 in [Gourgoulhon](https://arxiv.org/pdf/gr-qc/0703035.pdf):
# g_{tt} = -\alpha^2 + \beta^k \beta_k
# g_{ti} = \beta_i
# g_{ij} = \gamma_{ij}
# Eq. 2.121 in B&S
betaSphorCartD = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
betaSphorCartD[i] += gammaSphorCartDD[i][j] * betaSphorCartU[j]
# Now compute the beta contraction.
beta2 = sp.sympify(0)
for i in range(DIM):
beta2 += betaSphorCartU[i] * betaSphorCartD[i]
# Eq. 2.122 in B&S
g4SphorCartDD = ixp.zerorank2(DIM=4)
g4SphorCartDD[0][0] = -alphaSphorCart**2 + beta2
for i in range(DIM):
g4SphorCartDD[i + 1][0] = g4SphorCartDD[0][i + 1] = betaSphorCartD[i]
for i in range(DIM):
for j in range(DIM):
g4SphorCartDD[i + 1][j + 1] = gammaSphorCartDD[i][j]
# Step 2.2: Construct \gamma_{mu nu} = g_{mu nu} + n_mu n_nu:
n4SphorCartD = ixp.zerorank1(DIM=4)
n4SphorCartD[0] = -alphaSphorCart
gamma4SphorCartDD = ixp.zerorank2(DIM=4)
for mu in range(4):
for nu in range(4):
gamma4SphorCartDD[mu][nu] = g4SphorCartDD[mu][
nu] + n4SphorCartD[mu] * n4SphorCartD[nu]
# Step 2.3: We now have all we need to construct the BSSN source
# terms in the current basis (Spherical or Cartesian):
# S_{ij} = \gamma_{i \mu} \gamma_{j \nu} T^{\mu \nu}
# S_{i} = -\gamma_{i\mu} n_\nu T^{\mu\nu}
# S = \gamma^{ij} S_{ij}
# rho = n_\mu n_\nu T^{\mu\nu},
SSphorCartDD = ixp.zerorank2()
SSphorCartD = ixp.zerorank1()
SSphorCart = sp.sympify(0)
rhoSphorCart = sp.sympify(0)
for i in range(DIM):
for j in range(DIM):
for mu in range(4):
for nu in range(4):
SSphorCartDD[i][j] += gamma4SphorCartDD[
i + 1][mu] * gamma4SphorCartDD[
j + 1][nu] * T4SphorCartUU[mu][nu]
for i in range(DIM):
for mu in range(4):
for nu in range(4):
SSphorCartD[i] += -gamma4SphorCartDD[
i + 1][mu] * n4SphorCartD[nu] * T4SphorCartUU[mu][nu]
gammaSphorCartUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaSphorCartDD)
for i in range(DIM):
for j in range(DIM):
SSphorCart += gammaSphorCartUU[i][j] * SSphorCartDD[i][j]
for mu in range(4):
for nu in range(4):
rhoSphorCart += n4SphorCartD[mu] * n4SphorCartD[
nu] * T4SphorCartUU[mu][nu]
# Step 3: Perform basis conversion to
# Make sure that rfm.reference_metric() has been called.
# We'll need the variables it defines throughout this module.
if rfm.have_already_called_reference_metric_function == False:
print(
"Error. Called Tmunu_Numerical_Spherical_or_Cartesian_to_BSSNCurvilinear() without"
)
print(
" first setting up reference metric, by calling rfm.reference_metric()."
)
exit(1)
# Step 1: All input quantities are in terms of r,th,ph or x,y,z. We want them in terms
# of xx0,xx1,xx2, so here we call sympify_integers__replace_rthph() to replace
# r,th,ph or x,y,z, respectively, with the appropriate functions of xx0,xx1,xx2
# as defined for this particular reference metric in reference_metric.py's
# xxSph[] or xxCart[], respectively:
r_th_ph_or_Cart_xyz_oID_xx = []
if CoordType_in == "Spherical":
r_th_ph_or_Cart_xyz_oID_xx = rfm.xxSph
elif CoordType_in == "Cartesian":
r_th_ph_or_Cart_xyz_oID_xx = rfm.xxCart
else:
print(
"Error: Can only convert ADM Cartesian or Spherical initial data to BSSN Curvilinear coords."
)
exit(1)
# Next apply Jacobian transformations to convert into the (xx0,xx1,xx2) basis
# alpha is a scalar, so no Jacobian transformation is necessary.
alpha = alphaSphorCart
Jac_dUSphorCart_dDrfmUD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
Jac_dUSphorCart_dDrfmUD[i][j] = sp.diff(
r_th_ph_or_Cart_xyz_oID_xx[i], rfm.xx[j])
Jac_dUrfm_dDSphorCartUD, dummyDET = ixp.generic_matrix_inverter3x3(
Jac_dUSphorCart_dDrfmUD)
betaU = ixp.zerorank1()
BU = ixp.zerorank1()
gammaSphorCartDD = ixp.zerorank2()
KDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
betaU[i] += Jac_dUrfm_dDSphorCartUD[i][j] * betaSphorCartU[j]
BU[i] += Jac_dUrfm_dDSphorCartUD[i][j] * BSphorCartU[j]
for k in range(DIM):
for l in range(DIM):
gammaSphorCartDD[i][j] += Jac_dUSphorCart_dDrfmUD[k][i] * Jac_dUSphorCart_dDrfmUD[l][j] * \
gammaSphorCartDD[k][l]
KDD[i][j] += Jac_dUSphorCart_dDrfmUD[k][
i] * Jac_dUSphorCart_dDrfmUD[l][j] * KSphorCartDD[k][l]
# Step 3: All ADM quantities were input into this function in the Spherical or Cartesian
# basis, as functions of r,th,ph or x,y,z, respectively. In Steps 1 and 2 above,
# we converted them to the xx0,xx1,xx2 basis, and as functions of xx0,xx1,xx2.
# Here we convert ADM quantities to their BSSN Curvilinear counterparts:
# Step 3.1: Convert ADM $\gamma_{ij}$ to BSSN $\bar{\gamma}_{ij}$:
# We have (Eqs. 2 and 3 of [Ruchlin *et al.*](https://arxiv.org/pdf/1712.07658.pdf)):
# \bar{\gamma}_{i j} = \left(\frac{\bar{\gamma}}{\gamma}\right)^{1/3} \gamma_{ij}.
gammaSphorCartUU, gammaDET = ixp.symm_matrix_inverter3x3(gammaSphorCartDD)
gammabarDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
gammabarDD[i][j] = (rfm.detgammahat / gammaDET)**(sp.Rational(
1, 3)) * gammaSphorCartDD[i][j]
# Step 3.2: Convert the extrinsic curvature $K_{ij}$ to the trace-free extrinsic
# curvature $\bar{A}_{ij}$, plus the trace of the extrinsic curvature $K$,
# where (Eq. 3 of [Baumgarte *et al.*](https://arxiv.org/pdf/1211.6632.pdf)):
# K = \gamma^{ij} K_{ij}, and
# \bar{A}_{ij} &= \left(\frac{\bar{\gamma}}{\gamma}\right)^{1/3} \left(K_{ij} - \frac{1}{3} \gamma_{ij} K \right)
trK = sp.sympify(0)
for i in range(DIM):
for j in range(DIM):
trK += gammaSphorCartUU[i][j] * KDD[i][j]
AbarDD = ixp.zerorank2()
for i in range(DIM):
for j in range(DIM):
AbarDD[i][j] = (rfm.detgammahat / gammaDET)**(sp.Rational(
1, 3)) * (KDD[i][j] -
sp.Rational(1, 3) * gammaSphorCartDD[i][j] * trK)
# Step 3.3: Set the conformal factor variable $\texttt{cf}$, which is set
# by the "BSSN_RHSs::ConformalFactor" parameter. For example if
# "ConformalFactor" is set to "phi", we can use Eq. 3 of
# [Ruchlin *et al.*](https://arxiv.org/pdf/1712.07658.pdf),
# which in arbitrary coordinates is written:
# \phi = \frac{1}{12} \log\left(\frac{\gamma}{\bar{\gamma}}\right).
# Alternatively if "BSSN_RHSs::ConformalFactor" is set to "chi", then
# \chi = e^{-4 \phi} = \exp\left(-4 \frac{1}{12} \left(\frac{\gamma}{\bar{\gamma}}\right)\right)
# = \exp\left(-\frac{1}{3} \log\left(\frac{\gamma}{\bar{\gamma}}\right)\right) = \left(\frac{\gamma}{\bar{\gamma}}\right)^{-1/3}.
#
# Finally if "BSSN_RHSs::ConformalFactor" is set to "W", then
# W = e^{-2 \phi} = \exp\left(-2 \frac{1}{12} \log\left(\frac{\gamma}{\bar{\gamma}}\right)\right) =
# \exp\left(-\frac{1}{6} \log\left(\frac{\gamma}{\bar{\gamma}}\right)\right) =
# \left(\frac{\gamma}{\bar{\gamma}}\right)^{-1/6}.
# First compute gammabarDET:
gammabarUU, gammabarDET = ixp.symm_matrix_inverter3x3(gammabarDD)
cf = sp.sympify(0)
if par.parval_from_str("ConformalFactor") == "phi":
cf = sp.Rational(1, 12) * sp.log(gammaDET / gammabarDET)
elif par.parval_from_str("ConformalFactor") == "chi":
cf = (gammaDET / gammabarDET)**(-sp.Rational(1, 3))
elif par.parval_from_str("ConformalFactor") == "W":
cf = (gammaDET / gammabarDET)**(-sp.Rational(1, 6))
else:
print("Error ConformalFactor type = \"" +
par.parval_from_str("ConformalFactor") + "\" unknown.")
exit(1)
# Step 4: Rescale tensorial quantities according to the prescription described in
# the [BSSN in curvilinear coordinates tutorial module](Tutorial-BSSNCurvilinear.ipynb)
# (also [Ruchlin *et al.*](https://arxiv.org/pdf/1712.07658.pdf)):
#
# h_{ij} &= (\bar{\gamma}_{ij} - \hat{\gamma}_{ij})/\text{ReDD[i][j]}\\
# a_{ij} &= \bar{A}_{ij}/\text{ReDD[i][j]}\\
# \lambda^i &= \bar{\Lambda}^i/\text{ReU[i]}\\
# \mathcal{V}^i &= \beta^i/\text{ReU[i]}\\
# \mathcal{B}^i &= B^i/\text{ReU[i]}\\
hDD = ixp.zerorank2()
aDD = ixp.zerorank2()
vetU = ixp.zerorank1()
betU = ixp.zerorank1()
for i in range(DIM):
vetU[i] = betaU[i] / rfm.ReU[i]
betU[i] = BU[i] / rfm.ReU[i]
for j in range(DIM):
hDD[i][j] = (gammabarDD[i][j] - rfm.ghatDD[i][j]) / rfm.ReDD[i][j]
aDD[i][j] = AbarDD[i][j] / rfm.ReDD[i][j]
# Step 5: Output all ADM-to-BSSN expressions to a C function. This function
# must first call the ID_ADM_SphorCart() defined above. Using these
# Spherical or Cartesian data, it sets up all quantities needed for
# BSSNCurvilinear initial data, *except* $\lambda^i$, which must be
# computed from numerical data using finite-difference derivatives.
with open("BSSN/ID_ADM_xx0xx1xx2_to_BSSN_xx0xx1xx2__ALL_BUT_LAMBDAs.h",
"w") as file:
file.write(
"void ID_ADM_xx0xx1xx2_to_BSSN_xx0xx1xx2__ALL_BUT_LAMBDAs(const REAL xx0xx1xx2[3],"
)
if pointer_to_ID_inputs == True:
file.write("ID_inputs *other_inputs,")
else:
file.write("ID_inputs other_inputs,")
file.write("""
REAL *hDD00,REAL *hDD01,REAL *hDD02,REAL *hDD11,REAL *hDD12,REAL *hDD22,
REAL *aDD00,REAL *aDD01,REAL *aDD02,REAL *aDD11,REAL *aDD12,REAL *aDD22,
REAL *trK,
REAL *vetU0,REAL *vetU1,REAL *vetU2,
REAL *betU0,REAL *betU1,REAL *betU2,
REAL *alpha, REAL *cf) {
REAL gammaSphorCartDD00,gammaSphorCartDD01,gammaSphorCartDD02,
gammaSphorCartDD11,gammaSphorCartDD12,gammaSphorCartDD22;
REAL KSphorCartDD00,KSphorCartDD01,KSphorCartDD02,
KSphorCartDD11,KSphorCartDD12,KSphorCartDD22;
REAL alphaSphorCart,betaSphorCartU0,betaSphorCartU1,betaSphorCartU2;
REAL BSphorCartU0,BSphorCartU1,BSphorCartU2;
const REAL xx0 = xx0xx1xx2[0];
const REAL xx1 = xx0xx1xx2[1];
const REAL xx2 = xx0xx1xx2[2];
REAL xyz_or_rthph[3];\n""")
outCparams = "preindent=1,outCfileaccess=a,outCverbose=False,includebraces=False"
outputC(r_th_ph_or_Cart_xyz_oID_xx[0:3],
["xyz_or_rthph[0]", "xyz_or_rthph[1]", "xyz_or_rthph[2]"],
"BSSN/ID_ADM_xx0xx1xx2_to_BSSN_xx0xx1xx2__ALL_BUT_LAMBDAs.h",
outCparams + ",CSE_enable=False")
with open("BSSN/ID_ADM_xx0xx1xx2_to_BSSN_xx0xx1xx2__ALL_BUT_LAMBDAs.h",
"a") as file:
file.write(" " + ADM_input_function_name +
"""(xyz_or_rthph, other_inputs,
&gammaSphorCartDD00,&gammaSphorCartDD01,&gammaSphorCartDD02,
&gammaSphorCartDD11,&gammaSphorCartDD12,&gammaSphorCartDD22,
&KSphorCartDD00,&KSphorCartDD01,&KSphorCartDD02,
&KSphorCartDD11,&KSphorCartDD12,&KSphorCartDD22,
&alphaSphorCart,&betaSphorCartU0,&betaSphorCartU1,&betaSphorCartU2,
&BSphorCartU0,&BSphorCartU1,&BSphorCartU2);
// Next compute all rescaled BSSN curvilinear quantities:\n""")
outCparams = "preindent=1,outCfileaccess=a,outCverbose=False,includebraces=False"
outputC([
hDD[0][0], hDD[0][1], hDD[0][2], hDD[1][1], hDD[1][2], hDD[2][2],
aDD[0][0], aDD[0][1], aDD[0][2], aDD[1][1], aDD[1][2], aDD[2][2], trK,
vetU[0], vetU[1], vetU[2], betU[0], betU[1], betU[2], alpha, cf
], [
"*hDD00", "*hDD01", "*hDD02", "*hDD11", "*hDD12", "*hDD22", "*aDD00",
"*aDD01", "*aDD02", "*aDD11", "*aDD12", "*aDD22", "*trK", "*vetU0",
"*vetU1", "*vetU2", "*betU0", "*betU1", "*betU2", "*alpha", "*cf"
],
"BSSN/ID_ADM_xx0xx1xx2_to_BSSN_xx0xx1xx2__ALL_BUT_LAMBDAs.h",
params=outCparams)
with open("BSSN/ID_ADM_xx0xx1xx2_to_BSSN_xx0xx1xx2__ALL_BUT_LAMBDAs.h",
"a") as file:
file.write("}\n")
# Step 5.A: Output the driver function for the above
# function ID_ADM_xx0xx1xx2_to_BSSN_xx0xx1xx2__ALL_BUT_LAMBDAs()
# Next write the driver function for ID_ADM_xx0xx1xx2_to_BSSN_xx0xx1xx2__ALL_BUT_LAMBDAs():
with open("BSSN/ID_BSSN__ALL_BUT_LAMBDAs.h", "w") as file:
file.write(
"void ID_BSSN__ALL_BUT_LAMBDAs(const int Nxx_plus_2NGHOSTS[3],REAL *xx[3],"
)
if pointer_to_ID_inputs == True:
file.write("ID_inputs *other_inputs,")
else:
file.write("ID_inputs other_inputs,")
file.write("REAL *in_gfs) {\n")
file.write(
lp.loop(["i2", "i1", "i0"], ["0", "0", "0"], [
"Nxx_plus_2NGHOSTS[2]", "Nxx_plus_2NGHOSTS[1]",
"Nxx_plus_2NGHOSTS[0]"
], ["1", "1", "1"], [
"#pragma omp parallel for", " const REAL xx2 = xx[2][i2];",
" const REAL xx1 = xx[1][i1];"
], "", """const REAL xx0 = xx[0][i0];
const int idx = IDX3(i0,i1,i2);
const REAL xx0xx1xx2[3] = {xx0,xx1,xx2};
ID_ADM_xx0xx1xx2_to_BSSN_xx0xx1xx2__ALL_BUT_LAMBDAs(xx0xx1xx2,other_inputs,
&in_gfs[IDX4pt(HDD00GF,idx)],&in_gfs[IDX4pt(HDD01GF,idx)],&in_gfs[IDX4pt(HDD02GF,idx)],
&in_gfs[IDX4pt(HDD11GF,idx)],&in_gfs[IDX4pt(HDD12GF,idx)],&in_gfs[IDX4pt(HDD22GF,idx)],
&in_gfs[IDX4pt(ADD00GF,idx)],&in_gfs[IDX4pt(ADD01GF,idx)],&in_gfs[IDX4pt(ADD02GF,idx)],
&in_gfs[IDX4pt(ADD11GF,idx)],&in_gfs[IDX4pt(ADD12GF,idx)],&in_gfs[IDX4pt(ADD22GF,idx)],
&in_gfs[IDX4pt(TRKGF,idx)],
&in_gfs[IDX4pt(VETU0GF,idx)],&in_gfs[IDX4pt(VETU1GF,idx)],&in_gfs[IDX4pt(VETU2GF,idx)],
&in_gfs[IDX4pt(BETU0GF,idx)],&in_gfs[IDX4pt(BETU1GF,idx)],&in_gfs[IDX4pt(BETU2GF,idx)],
&in_gfs[IDX4pt(ALPHAGF,idx)],&in_gfs[IDX4pt(CFGF,idx)]);
"""))
file.write("}\n")
# Step 6: Compute $\bar{\Lambda}^i$ (Eqs. 4 and 5 of
# [Baumgarte *et al.*](https://arxiv.org/pdf/1211.6632.pdf)),
# from finite-difference derivatives of rescaled metric
# quantities $h_{ij}$:
# \bar{\Lambda}^i = \bar{\gamma}^{jk}\left(\bar{\Gamma}^i_{jk} - \hat{\Gamma}^i_{jk}\right).
# The reference_metric.py module provides us with analytic expressions for
# $\hat{\Gamma}^i_{jk}$, so here we need only compute
# finite-difference expressions for $\bar{\Gamma}^i_{jk}$, based on
# the values for $h_{ij}$ provided in the initial data. Once
# $\bar{\Lambda}^i$ has been computed, we apply the usual rescaling
# procedure:
# \lambda^i = \bar{\Lambda}^i/\text{ReU[i]},
# and then output the result to a C file using the NRPy+
# finite-difference C output routine.
# We will need all BSSN gridfunctions to be defined, as well as
# expressions for gammabarDD_dD in terms of exact derivatives of
# the rescaling matrix and finite-difference derivatives of
# hDD's.
gammabarDD = bssnrhs.gammabarDD
gammabarUU, gammabarDET = ixp.symm_matrix_inverter3x3(gammabarDD)
gammabarDD_dD = bssnrhs.gammabarDD_dD
# Next compute Christoffel symbols \bar{\Gamma}^i_{jk}:
GammabarUDD = ixp.zerorank3()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
for l in range(DIM):
GammabarUDD[i][j][k] += sp.Rational(
1,
2) * gammabarUU[i][l] * (gammabarDD_dD[l][j][k] +
gammabarDD_dD[l][k][j] -
gammabarDD_dD[j][k][l])
# Next evaluate \bar{\Lambda}^i, based on GammabarUDD above and GammahatUDD
# (from the reference metric):
LambdabarU = ixp.zerorank1()
for i in range(DIM):
for j in range(DIM):
for k in range(DIM):
LambdabarU[i] += gammabarUU[j][k] * (
GammabarUDD[i][j][k] - rfm.GammahatUDD[i][j][k])
# Finally apply rescaling:
# lambda^i = Lambdabar^i/\text{ReU[i]}
lambdaU = ixp.zerorank1()
for i in range(DIM):
lambdaU[i] = LambdabarU[i] / rfm.ReU[i]
outCparams = "preindent=1,outCfileaccess=a,outCverbose=False,includebraces=False"
lambdaU_expressions = [
lhrh(lhs=gri.gfaccess("in_gfs", "lambdaU0"), rhs=lambdaU[0]),
lhrh(lhs=gri.gfaccess("in_gfs", "lambdaU1"), rhs=lambdaU[1]),
lhrh(lhs=gri.gfaccess("in_gfs", "lambdaU2"), rhs=lambdaU[2])
]
lambdaU_expressions_FDout = fin.FD_outputC("returnstring",
lambdaU_expressions,
outCparams)
with open("BSSN/ID_BSSN_lambdas.h", "w") as file:
file.write("""
void ID_BSSN_lambdas(const int Nxx[3],const int Nxx_plus_2NGHOSTS[3],REAL *xx[3],const REAL dxx[3],REAL *in_gfs) {\n"""
)
file.write(
lp.loop(["i2", "i1", "i0"], ["NGHOSTS", "NGHOSTS", "NGHOSTS"],
["NGHOSTS+Nxx[2]", "NGHOSTS+Nxx[1]", "NGHOSTS+Nxx[0]"],
["1", "1", "1"], [
"const REAL invdx0 = 1.0/dxx[0];\n" +
"const REAL invdx1 = 1.0/dxx[1];\n" +
"const REAL invdx2 = 1.0/dxx[2];\n" +
"#pragma omp parallel for",
" const REAL xx2 = xx[2][i2];",
" const REAL xx1 = xx[1][i1];"
], "", "const REAL xx0 = xx[0][i0];\n" +
lambdaU_expressions_FDout))
file.write("}\n")
