def declare_BSSN_gridfunctions_if_not_declared_already(): # Step 2: Register all needed BSSN gridfunctions. # Declare as globals all variables that may be # used outside this function global hDD, aDD, lambdaU, vetU, betU, trK, cf, alpha # Check to see if this function has already been called. # If so, do not register the gridfunctions again! for i in range(len(gri.glb_gridfcs_list)): if "hDD00" in gri.glb_gridfcs_list[i].name: hDD = ixp.declarerank2("hDD", "sym01") aDD = ixp.declarerank2("aDD", "sym01") lambdaU = ixp.declarerank1("lambdaU") vetU = ixp.declarerank1("vetU") betU = ixp.declarerank1("betU") trK, cf, alpha = sp.symbols('trK cf alpha', real=True) return hDD, aDD, lambdaU, vetU, betU, trK, cf, alpha # Step 2.a: Register indexed quantities, using ixp.register_... functions hDD = ixp.register_gridfunctions_for_single_rank2("EVOL", "hDD", "sym01") aDD = ixp.register_gridfunctions_for_single_rank2("EVOL", "aDD", "sym01") lambdaU = ixp.register_gridfunctions_for_single_rank1("EVOL", "lambdaU") vetU = ixp.register_gridfunctions_for_single_rank1("EVOL", "vetU") betU = ixp.register_gridfunctions_for_single_rank1("EVOL", "betU") # Step 2.b: Register scalar quantities, using gri.register_gridfunctions() trK, cf, alpha = gri.register_gridfunctions("EVOL", ["trK", "cf", "alpha"]) return hDD, aDD, lambdaU, vetU, betU, trK, cf, alpha
def generate_everything_for_UnitTesting(): # First define hydrodynamical quantities u4U = ixp.declarerank1("u4U", DIM=4) rho_b, P, epsilon = sp.symbols('rho_b P epsilon', real=True) # Then ADM quantities gammaDD = ixp.declarerank2("gammaDD", "sym01", DIM=3) KDD = ixp.declarerank2("KDD", "sym01", DIM=3) betaU = ixp.declarerank1("betaU", DIM=3) alpha = sp.symbols('alpha', real=True) # First compute stress-energy tensor T4UU and T4UD: compute_T4UU(gammaDD, betaU, alpha, rho_b, P, epsilon, u4U) compute_T4UD(gammaDD, betaU, alpha, T4UU) # Next sqrt(gamma) compute_sqrtgammaDET(gammaDD) # Compute conservative variables in terms of primitive variables compute_rho_star(alpha, sqrtgammaDET, rho_b, u4U) compute_tau_tilde(alpha, sqrtgammaDET, T4UU, rho_star) compute_S_tildeD(alpha, sqrtgammaDET, T4UD) # Then compute v^i from u^mu compute_vU_from_u4U__no_speed_limit(u4U) # Next compute fluxes of conservative variables compute_rho_star_fluxU(vU, rho_star) compute_tau_tilde_fluxU(alpha, sqrtgammaDET, vU, T4UU, rho_star) compute_S_tilde_fluxUD(alpha, sqrtgammaDET, T4UD) # Then declare derivatives & compute g4DD_zerotimederiv_dD gammaDD_dD = ixp.declarerank3("gammaDD_dD", "sym01", DIM=3) betaU_dD = ixp.declarerank2("betaU_dD", "nosym", DIM=3) alpha_dD = ixp.declarerank1("alpha_dD", DIM=3) compute_g4DD_zerotimederiv_dD(gammaDD, betaU, alpha, gammaDD_dD, betaU_dD, alpha_dD) # Then compute source terms on tau_tilde and S_tilde equations compute_s_source_term(KDD, betaU, alpha, sqrtgammaDET, alpha_dD, T4UU) compute_S_tilde_source_termD(alpha, sqrtgammaDET, g4DD_zerotimederiv_dD, T4UU) # Then compute the 4-velocities in terms of an input Valencia 3-velocity testValenciavU[i] testValenciavU = ixp.declarerank1("testValenciavU", DIM=3) u4U_in_terms_of_ValenciavU__rescale_ValenciavU_by_applying_speed_limit( alpha, betaU, gammaDD, testValenciavU) # Finally compute the 4-velocities in terms of an input 3-velocity testvU[i] = u^i/u^0 testvU = ixp.declarerank1("testvU", DIM=3) u4U_in_terms_of_vU__rescale_vU_by_applying_speed_limit( alpha, betaU, gammaDD, testvU)
def ScalarField_Tmunu(): global T4UU # Step 1.c: 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.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: Import all basic (unrescaled) BSSN scalars & tensors Bq.BSSN_basic_tensors() alpha = Bq.alpha betaU = Bq.betaU # Step 1.g: Define ADM quantities in terms of BSSN quantities BtoA.ADM_in_terms_of_BSSN() gammaDD = BtoA.gammaDD gammaUU = BtoA.gammaUU # Step 1.h: Define scalar field quantitites sf_dD = ixp.declarerank1("sf_dD") Pi = sp.Symbol("sfM", real=True) # Step 2a: Set up \partial^{t}\varphi = Pi/alpha sf4dU = ixp.zerorank1(DIM=4) sf4dU[0] = Pi / alpha # Step 2b: Set up \partial^{i}\varphi = -Pi*beta^{i}/alpha + gamma^{ij}\partial_{j}\varphi for i in range(DIM): sf4dU[i + 1] = -Pi * betaU[i] / alpha for j in range(DIM): sf4dU[i + 1] += gammaUU[i][j] * sf_dD[j] # Step 2c: Set up \partial^{i}\varphi\partial_{i}\varphi = -Pi**2 + gamma^{ij}\partial_{i}\varphi\partial_{j}\varphi sf4d2 = -Pi**2 for i in range(DIM): for j in range(DIM): sf4d2 += gammaUU[i][j] * sf_dD[i] * sf_dD[j] # Step 3a: Setting up g^{\mu\nu} ADMg.g4UU_ito_BSSN_or_ADM("ADM", gammaDD=gammaDD, betaU=betaU, alpha=alpha, gammaUU=gammaUU) g4UU = ADMg.g4UU # Step 3b: Setting up T^{\mu\nu} for a massless scalar field T4UU = ixp.zerorank2(DIM=4) for mu in range(4): for nu in range(4): T4UU[mu][nu] = sf4dU[mu] * sf4dU[nu] - g4UU[mu][nu] * sf4d2 / 2
def GiRaFFE_NRPy_Afield_flux(Ccodesdir): cmd.mkdir(Ccodesdir) # Write out the code to a file. gammaDD = ixp.declarerank2("gammaDD", "sym01", DIM=3) betaU = ixp.declarerank1("betaU", DIM=3) alpha = sp.sympify("alpha") for flux_dirn in range(3): chsp.find_cmax_cmin(flux_dirn, gammaDD, betaU, alpha) Ccode_kernel = outputC([chsp.cmax, chsp.cmin], ["cmax", "cmin"], "returnstring", params="outCverbose=False,CSE_sorting=none") Ccode_kernel = Ccode_kernel.replace("cmax", "*cmax").replace("cmin", "*cmin") Ccode_kernel = Ccode_kernel.replace("betaU0", "betaUi").replace( "betaU1", "betaUi").replace("betaU2", "betaUi") with open( os.path.join(Ccodesdir, "compute_cmax_cmin_dirn" + str(flux_dirn) + ".h"), "w") as file: file.write(Ccode_kernel) with open(os.path.join(Ccodesdir, name + ".h"), "w") as file: file.write(body)
def write_out_functions_for_StildeD_source_term(outdir,outCparams,gammaDD,betaU,alpha,ValenciavU,BU,sqrt4pi): generate_memory_access_code() # First, we declare some dummy tensors that we will use for the codegen. gammaDDdD = ixp.declarerank3("gammaDDdD","sym01",DIM=3) betaUdD = ixp.declarerank2("betaUdD","nosym",DIM=3) alphadD = ixp.declarerank1("alphadD",DIM=3) # We need to rerun a few of these functions with the reset lists to make sure these functions # don't cheat by using analytic expressions GRHD.compute_sqrtgammaDET(gammaDD) GRHD.u4U_in_terms_of_ValenciavU__rescale_ValenciavU_by_applying_speed_limit(alpha, betaU, gammaDD, ValenciavU) GRFFE.compute_smallb4U(gammaDD, betaU, alpha, GRHD.u4U_ito_ValenciavU, BU, sqrt4pi) GRFFE.compute_smallbsquared(gammaDD, betaU, alpha, GRFFE.smallb4U) GRFFE.compute_TEM4UU(gammaDD,betaU,alpha, GRFFE.smallb4U, GRFFE.smallbsquared,GRHD.u4U_ito_ValenciavU) GRHD.compute_g4DD_zerotimederiv_dD(gammaDD,betaU,alpha, gammaDDdD,betaUdD,alphadD) GRHD.compute_S_tilde_source_termD(alpha, GRHD.sqrtgammaDET,GRHD.g4DD_zerotimederiv_dD, GRFFE.TEM4UU) for i in range(3): desc = "Adds the source term to StildeD"+str(i)+"." name = "calculate_StildeD"+str(i)+"_source_term" outCfunction( outfile = os.path.join(outdir,name+".h"), desc=desc, name=name, params ="const paramstruct *params,const REAL *auxevol_gfs, REAL *rhs_gfs", body = general_access \ +metric_deriv_access[i]\ +outputC(GRHD.S_tilde_source_termD[i],"Stilde_rhsD"+str(i),"returnstring",params=outCparams).replace("IDX4","IDX4S")\ +write_final_quantity[i], loopopts ="InteriorPoints", rel_path_for_Cparams=os.path.join("../"))
def BSSN_source_terms_for_BSSN_constraints(custom_T4UU=None): global sourceterm_H, sourceterm_MU # Step 4.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") # Step 4.b: Add source term to the Hamiltonian constraint H sourceterm_H = -16 * PI * rho # Step 4.c: Add source term to the momentum constraint M^i # Step 4.c.i: Compute gammaUU in terms of BSSN quantities import BSSN.ADM_in_terms_of_BSSN as AitoB AitoB.ADM_in_terms_of_BSSN() # Provides gammaUU # Step 4.c.ii: Raise S_i SU = ixp.zerorank1() for i in range(3): for j in range(3): SU[i] += AitoB.gammaUU[i][j] * SD[j] # Step 4.c.iii: Add source term to momentum constraint & rescale: sourceterm_MU = ixp.zerorank1() for i in range(3): sourceterm_MU[i] = -8 * PI * SU[i] / rfm.ReU[i]
def generate_everything_for_UnitTesting(): # First define hydrodynamical quantities u4U = ixp.declarerank1("u4U", DIM=4) B_tildeU = ixp.declarerank1("B_tildeU", DIM=3) # Then ADM quantities gammaDD = ixp.declarerank2("gammaDD", "sym01", DIM=3) betaU = ixp.declarerank1("betaU", DIM=3) alpha = sp.symbols('alpha', real=True) # Then numerical constant sqrt4pi = sp.symbols('sqrt4pi', real=True) # First compute stress-energy tensor T4UU and T4UD: import GRHD.equations as GHeq GHeq.compute_sqrtgammaDET(gammaDD) compute_B_notildeU(GHeq.sqrtgammaDET, B_tildeU) compute_smallb4U(gammaDD, betaU, alpha, u4U, B_notildeU, sqrt4pi) compute_smallb4U_with_driftvU_for_FFE(gammaDD, betaU, alpha, u4U, B_notildeU, sqrt4pi) compute_smallbsquared(gammaDD, betaU, alpha, smallb4U) compute_TEM4UU(gammaDD, betaU, alpha, smallb4U, smallbsquared, u4U) compute_TEM4UD(gammaDD, betaU, alpha, TEM4UU) # Compute conservative variables in terms of primitive variables GHeq.compute_S_tildeD(alpha, GHeq.sqrtgammaDET, TEM4UD) global S_tildeD S_tildeD = GHeq.S_tildeD # Next compute fluxes of conservative variables GHeq.compute_S_tilde_fluxUD(alpha, GHeq.sqrtgammaDET, TEM4UD) global S_tilde_fluxUD S_tilde_fluxUD = GHeq.S_tilde_fluxUD # Then declare derivatives & compute g4DDdD gammaDD_dD = ixp.declarerank3("gammaDD_dD", "sym01", DIM=3) betaU_dD = ixp.declarerank2("betaU_dD", "nosym", DIM=3) alpha_dD = ixp.declarerank1("alpha_dD", DIM=3) GHeq.compute_g4DD_zerotimederiv_dD(gammaDD, betaU, alpha, gammaDD_dD, betaU_dD, alpha_dD) # Finally compute source terms on tau_tilde and S_tilde equations GHeq.compute_S_tilde_source_termD(alpha, GHeq.sqrtgammaDET, GHeq.g4DD_zerotimederiv_dD, TEM4UU) global S_tilde_source_termD S_tilde_source_termD = GHeq.S_tilde_source_termD
def betU_vetU(betaU, BU): global vetU, betU if betaU == None: betaU = ixp.declarerank1("betaU") if BU == None: BU = ixp.declarerank1("BU") if rfm.have_already_called_reference_metric_function == False: print( "BSSN.BSSN_in_terms_of_ADM.bet_vet(): Must call reference_metric() first!" ) sys.exit(1) 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]
def ScalarWaveCurvilinear_RHSs(): # Step 1: Get the spatial dimension, defined in the # NRPy+ "grid" module. With reference metrics, # this must be set to 3 or fewer. DIM = par.parval_from_str("DIM") # Step 2: Set up the reference metric and # quantities derived from the # reference metric. rfm.reference_metric() # Step 3: Compute the contracted Christoffel symbols: contractedGammahatU = ixp.zerorank1() for k in range(DIM): for i in range(DIM): for j in range(DIM): contractedGammahatU[k] += rfm.ghatUU[i][j] * rfm.GammahatUDD[k][i][j] # Step 4: Register gridfunctions that are needed as input # to the scalar wave RHS expressions. uu, vv = gri.register_gridfunctions("EVOL",["uu","vv"]) # Step 5a: Declare the rank-1 indexed expression \partial_{i} u, # Derivative variables like these must have an underscore # in them, so the finite difference module can parse the # variable name properly. uu_dD = ixp.declarerank1("uu_dD") # Step 5b: Declare the rank-2 indexed expression \partial_{ij} u, # which is symmetric about interchange of indices i and j # Derivative variables like these must have an underscore # in them, so the finite difference module can parse the # variable name properly. uu_dDD = ixp.declarerank2("uu_dDD","sym01") # Step 7: Specify RHSs as global variables, # to enable access outside this # function (e.g., for C code output) global uu_rhs,vv_rhs # Step 6: Define right-hand sides for the evolution. # Step 6a: uu_rhs = vv: uu_rhs = vv # Step 6b: The right-hand side of the \partial_t v equation # is given by: # \hat{g}^{ij} \partial_i \partial_j u - \hat{\Gamma}^i \partial_i u. # ^^^^^^^^^^^^ PART 1 ^^^^^^^^^^^^^^^^ ^^^^^^^^^^ PART 2 ^^^^^^^^^^^ vv_rhs = 0 for i in range(DIM): # PART 2: vv_rhs -= contractedGammahatU[i]*uu_dD[i] for j in range(DIM): # PART 1: vv_rhs += rfm.ghatUU[i][j]*uu_dDD[i][j] vv_rhs *= wavespeed*wavespeed
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 BrillLindquist(ComputeADMGlobalsOnly=False, include_NRPy_basic_defines_and_pickle=False): # Step 2: Setting up Brill-Lindquist initial data # Step 2.a: Set spatial dimension (must be 3 for BSSN) DIM = 3 par.set_parval_from_str("grid::DIM", DIM) global Cartxyz, gammaCartDD, KCartDD, alphaCart, betaCartU, BCartU Cartxyz = ixp.declarerank1("Cartxyz") # Step 2.b: Set psi, the conformal factor: psi = sp.sympify(1) psi += BH1_mass / (2 * sp.sqrt((Cartxyz[0] - BH1_posn_x)**2 + (Cartxyz[1] - BH1_posn_y)**2 + (Cartxyz[2] - BH1_posn_z)**2)) psi += BH2_mass / (2 * sp.sqrt((Cartxyz[0] - BH2_posn_x)**2 + (Cartxyz[1] - BH2_posn_y)**2 + (Cartxyz[2] - BH2_posn_z)**2)) # Step 2.c: Set all needed ADM variables in Cartesian coordinates gammaCartDD = ixp.zerorank2() KCartDD = ixp.zerorank2() # K_{ij} = 0 for these initial data for i in range(DIM): gammaCartDD[i][i] = psi**4 alphaCart = 1 / psi**2 betaCartU = ixp.zerorank1( ) # We generally choose \beta^i = 0 for these initial data BCartU = ixp.zerorank1( ) # We generally choose B^i = 0 for these initial data if ComputeADMGlobalsOnly == True: return cf,hDD,lambdaU,aDD,trK,alpha,vetU,betU = \ AtoB.Convert_Spherical_or_Cartesian_ADM_to_BSSN_curvilinear("Cartesian",Cartxyz, gammaCartDD,KCartDD,alphaCart,betaCartU,BCartU) import BSSN.BSSN_ID_function_string as bIDf # Generates initial_data() C function & stores to outC_function_dict["initial_data"] bIDf.BSSN_ID_function_string( cf, hDD, lambdaU, aDD, trK, alpha, vetU, betU, include_NRPy_basic_defines=include_NRPy_basic_defines_and_pickle) if include_NRPy_basic_defines_and_pickle: return pickle_NRPy_env()
def BrillLindquist(ComputeADMGlobalsOnly=False): global Cartxyz, gammaCartDD, KCartDD, alphaCart, betaCartU, BCartU # Step 2: Setting up Brill-Lindquist initial data thismodule = "Brill-Lindquist" BH1_posn_x, BH1_posn_y, BH1_posn_z = par.Cparameters( "REAL", thismodule, ["BH1_posn_x", "BH1_posn_y", "BH1_posn_z"]) BH1_mass = par.Cparameters("REAL", thismodule, ["BH1_mass"]) BH2_posn_x, BH2_posn_y, BH2_posn_z = par.Cparameters( "REAL", thismodule, ["BH2_posn_x", "BH2_posn_y", "BH2_posn_z"]) BH2_mass = par.Cparameters("REAL", thismodule, ["BH2_mass"]) # Step 2.a: Set spatial dimension (must be 3 for BSSN) DIM = 3 par.set_parval_from_str("grid::DIM", DIM) global Cartxyz, gammaCartDD, KCartDD, alphaCart, betaCartU, BCartU Cartxyz = ixp.declarerank1("Cartxyz") # Step 2.b: Set psi, the conformal factor: psi = sp.sympify(1) psi += BH1_mass / (2 * sp.sqrt((Cartxyz[0] - BH1_posn_x)**2 + (Cartxyz[1] - BH1_posn_y)**2 + (Cartxyz[2] - BH1_posn_z)**2)) psi += BH2_mass / (2 * sp.sqrt((Cartxyz[0] - BH2_posn_x)**2 + (Cartxyz[1] - BH2_posn_y)**2 + (Cartxyz[2] - BH2_posn_z)**2)) # Step 2.c: Set all needed ADM variables in Cartesian coordinates gammaCartDD = ixp.zerorank2() KCartDD = ixp.zerorank2() # K_{ij} = 0 for these initial data for i in range(DIM): gammaCartDD[i][i] = psi**4 alphaCart = 1 / psi**2 betaCartU = ixp.zerorank1( ) # We generally choose \beta^i = 0 for these initial data BCartU = ixp.zerorank1( ) # We generally choose B^i = 0 for these initial data if ComputeADMGlobalsOnly == True: return cf,hDD,lambdaU,aDD,trK,alpha,vetU,betU = \ AtoB.Convert_Spherical_or_Cartesian_ADM_to_BSSN_curvilinear("Cartesian",Cartxyz, gammaCartDD,KCartDD,alphaCart,betaCartU,BCartU) global returnfunction returnfunction = bIDf.BSSN_ID_function_string(cf, hDD, lambdaU, aDD, trK, alpha, vetU, betU)
def calculate_E_i_flux(flux_dirn,inputs_provided=True,alpha_face=None,gamma_faceDD=None,beta_faceU=None,\ Valenciav_rU=None,B_rU=None,Valenciav_lU=None,B_lU=None): if not inputs_provided: # declare all variables alpha_face = sp.symbols(alpha_face) beta_faceU = ixp.declarerank1("beta_faceU") gamma_faceDD = ixp.declarerank2("gamma_faceDD", "sym01") Valenciav_rU = ixp.declarerank1("Valenciav_rU") B_rU = ixp.declarerank1("B_rU") Valenciav_lU = ixp.declarerank1("Valenciav_lU") B_lU = ixp.declarerank1("B_lU") global E_fluxD E_fluxD = ixp.zerorank1() for field_comp in range(3): find_cmax_cmin(field_comp, gamma_faceDD, beta_faceU, alpha_face) calculate_flux_and_state_for_Induction(field_comp,flux_dirn, gamma_faceDD,beta_faceU,alpha_face,\ Valenciav_rU,B_rU) Fr = F Ur = U calculate_flux_and_state_for_Induction(field_comp,flux_dirn, gamma_faceDD,beta_faceU,alpha_face,\ Valenciav_lU,B_lU) Fl = F Ul = U E_fluxD[field_comp] += HLLE_solver(cmax, cmin, Fr, Fl, Ur, Ul)
def setup_ADM_quantities(inputvars): if inputvars == "ADM": gammaDD = ixp.declarerank2("gammaDD", "sym01") betaU = ixp.declarerank1("betaU") alpha = sp.symbols("alpha", real=True) elif inputvars == "BSSN": import BSSN.ADM_in_terms_of_BSSN as AitoB # Construct gamma_{ij} in terms of cf & gammabar_{ij} AitoB.ADM_in_terms_of_BSSN() gammaDD = AitoB.gammaDD # Next construct beta^i in terms of vet^i and reference metric quantities import BSSN.BSSN_quantities as Bq Bq.BSSN_basic_tensors() betaU = Bq.betaU alpha = sp.symbols("alpha", real=True) else: print("inputvars = " + str(inputvars) + " not supported. Please choose ADM or BSSN.") sys.exit(1) return gammaDD,betaU,alpha
def add_to_Cfunction_dict__AD_gauge_term_psi6Phi_fin_diff(includes=None): xi_damping = par.Cparameters("REAL",thismodule,"xi_damping",0.1) GRFFE.compute_psi6Phi_rhs_damping_term(alpha,psi6Phi,xi_damping) AevolParen_dD = ixp.declarerank1("AevolParen_dD",DIM=3) PhievolParenU_dD = ixp.declarerank2("PhievolParenU_dD","nosym",DIM=3) A_rhsD = ixp.zerorank1() psi6Phi_rhs = GRFFE.psi6Phi_damping for i in range(3): A_rhsD[i] += -AevolParen_dD[i] psi6Phi_rhs += -PhievolParenU_dD[i][i] # Add Kreiss-Oliger dissipation to the GRFFE RHSs: # psi6Phi_dKOD = ixp.declarerank1("psi6Phi_dKOD") # AD_dKOD = ixp.declarerank2("AD_dKOD","nosym") # for i in range(3): # psi6Phi_rhs += diss_strength*psi6Phi_dKOD[i]*rfm.ReU[i] # ReU[i] = 1/scalefactor_orthog_funcform[i] # for j in range(3): # A_rhsD[j] += diss_strength*AD_dKOD[j][i]*rfm.ReU[i] # ReU[i] = 1/scalefactor_orthog_funcform[i] RHSs_to_print = [ lhrh(lhs=gri.gfaccess("rhs_gfs","AD0"),rhs=A_rhsD[0]), lhrh(lhs=gri.gfaccess("rhs_gfs","AD1"),rhs=A_rhsD[1]), lhrh(lhs=gri.gfaccess("rhs_gfs","AD2"),rhs=A_rhsD[2]), lhrh(lhs=gri.gfaccess("rhs_gfs","psi6Phi"),rhs=psi6Phi_rhs), ] desc = "Calculate AD gauge term and psi6Phi RHSs" name = "calculate_AD_gauge_psi6Phi_RHSs" params ="const paramstruct *params,const REAL *in_gfs,const REAL *auxevol_gfs,REAL *rhs_gfs" body = fin.FD_outputC("returnstring",RHSs_to_print,params=outCparams) loopopts ="InteriorPoints" add_to_Cfunction_dict( includes=includes, desc=desc, name=name, params=params, body=body, loopopts=loopopts) outC_function_dict[name] = outC_function_dict[name].replace("= NGHOSTS","= NGHOSTS_A2B").replace("NGHOSTS+Nxx0","Nxx_plus_2NGHOSTS0-NGHOSTS_A2B").replace("NGHOSTS+Nxx1","Nxx_plus_2NGHOSTS1-NGHOSTS_A2B").replace("NGHOSTS+Nxx2","Nxx_plus_2NGHOSTS2-NGHOSTS_A2B")
def GiRaFFE_NRPy_P2C(gammaDD, betaU, alpha, ValenciavU, BU, sqrt4pi): # After recalculating the 3-velocity, we need to update the poynting flux: # We'll reset the Valencia velocity, since this will be part of a second call to outCfunction. ValenciavU = ixp.declarerank1("ValenciavU", DIM=3) # First compute stress-energy tensor T4UU and T4UD: GRHD.compute_sqrtgammaDET(gammaDD) GRHD.u4U_in_terms_of_ValenciavU__rescale_ValenciavU_by_applying_speed_limit( alpha, betaU, gammaDD, ValenciavU) GRFFE.compute_smallb4U(gammaDD, betaU, alpha, GRHD.u4U_ito_ValenciavU, BU, sqrt4pi) GRFFE.compute_smallbsquared(gammaDD, betaU, alpha, GRFFE.smallb4U) GRFFE.compute_TEM4UU(gammaDD, betaU, alpha, GRFFE.smallb4U, GRFFE.smallbsquared, GRHD.u4U_ito_ValenciavU) GRFFE.compute_TEM4UD(gammaDD, betaU, alpha, GRFFE.TEM4UU) # Compute conservative variables in terms of primitive variables GRHD.compute_S_tildeD(alpha, GRHD.sqrtgammaDET, GRFFE.TEM4UD) global StildeD StildeD = GRHD.S_tildeD
def phi_and_derivs(): # Step 9.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 phi_dD, phi_dupD, phi_dDD, exp_m4phi, phi_dBarD, phi_dBarDD hDD, aDD, lambdaU, vetU, betU, trK, cf, alpha = declare_BSSN_gridfunctions_if_not_declared_already( ) DIM = 3 # GammabarUDD is used below, defined in # gammabar__inverse_and_derivs() gammabar__inverse_and_derivs() # Step 9.a.i: Define partial derivatives of \phi in terms of evolved quantity "cf": cf_dD = ixp.declarerank1("cf_dD") cf_dupD = ixp.declarerank1("cf_dupD") # Needed for \partial_t \phi next. cf_dDD = ixp.declarerank2("cf_dDD", "sym01") phi_dD = ixp.zerorank1() phi_dupD = ixp.zerorank1() phi_dDD = ixp.zerorank2() exp_m4phi = sp.sympify(0) # Step 9.a.ii: Assuming cf=phi, define exp_m4phi, phi_dD, # phi_dupD (upwind finite-difference version of phi_dD), and phi_DD if par.parval_from_str( "BSSN.BSSN_quantities::EvolvedConformalFactor_cf") == "phi": for i in range(DIM): phi_dD[i] = cf_dD[i] phi_dupD[i] = cf_dupD[i] for j in range(DIM): phi_dDD[i][j] = cf_dDD[i][j] exp_m4phi = sp.exp(-4 * cf) # Step 9.a.iii: Assuming cf=W=e^{-2 phi}, define exp_m4phi, phi_dD, # phi_dupD (upwind finite-difference version of phi_dD), and phi_DD if par.parval_from_str( "BSSN.BSSN_quantities::EvolvedConformalFactor_cf") == "W": # \partial_i W = \partial_i (e^{-2 phi}) = -2 e^{-2 phi} \partial_i phi # -> \partial_i phi = -\partial_i cf / (2 cf) for i in range(DIM): phi_dD[i] = -cf_dD[i] / (2 * cf) phi_dupD[i] = -cf_dupD[i] / (2 * cf) for j in range(DIM): # \partial_j \partial_i phi = - \partial_j [\partial_i cf / (2 cf)] # = - cf_{,ij} / (2 cf) + \partial_i cf \partial_j cf / (2 cf^2) phi_dDD[i][j] = (-cf_dDD[i][j] + cf_dD[i] * cf_dD[j] / cf) / (2 * cf) exp_m4phi = cf * cf # Step 9.a.iv: Assuming cf=chi=e^{-4 phi}, define exp_m4phi, phi_dD, # phi_dupD (upwind finite-difference version of phi_dD), and phi_DD if par.parval_from_str( "BSSN.BSSN_quantities::EvolvedConformalFactor_cf") == "chi": # \partial_i chi = \partial_i (e^{-4 phi}) = -4 e^{-4 phi} \partial_i phi # -> \partial_i phi = -\partial_i cf / (4 cf) for i in range(DIM): phi_dD[i] = -cf_dD[i] / (4 * cf) phi_dupD[i] = -cf_dupD[i] / (4 * cf) for j in range(DIM): # \partial_j \partial_i phi = - \partial_j [\partial_i cf / (4 cf)] # = - cf_{,ij} / (4 cf) + \partial_i cf \partial_j cf / (4 cf^2) phi_dDD[i][j] = (-cf_dDD[i][j] + cf_dD[i] * cf_dD[j] / cf) / (4 * cf) exp_m4phi = cf # Step 9.a.v: Error out if unsupported EvolvedConformalFactor_cf choice is made: cf_choice = par.parval_from_str( "BSSN.BSSN_quantities::EvolvedConformalFactor_cf") if not (cf_choice == "phi" or cf_choice == "W" or cf_choice == "chi"): print("Error: EvolvedConformalFactor_cf == " + par.parval_from_str( "BSSN.BSSN_quantities::EvolvedConformalFactor_cf") + " unsupported!") exit(1) # Step 9.b: Define phi_dBarD = phi_dD (since phi is a scalar) and phi_dBarDD (covariant derivative) # \bar{D}_i \bar{D}_j \phi = \phi_{;\bar{i}\bar{j}} = \bar{D}_i \phi_{,j} # = \phi_{,ij} - \bar{\Gamma}^k_{ij} \phi_{,k} phi_dBarD = phi_dD phi_dBarDD = ixp.zerorank2() for i in range(DIM): for j in range(DIM): phi_dBarDD[i][j] = phi_dDD[i][j] for k in range(DIM): phi_dBarDD[i][j] += -GammabarUDD[k][i][j] * phi_dD[k]
def BSSN_RHSs(): # 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() global have_already_called_BSSN_RHSs_function # setting to global enables other modules to see updated value. have_already_called_BSSN_RHSs_function = True # 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 AbarDD = Bq.AbarDD LambdabarU = Bq.LambdabarU trK = Bq.trK alpha = Bq.alpha betaU = Bq.betaU # Step 1.f: Import all neeeded rescaled BSSN tensors: aDD = Bq.aDD cf = Bq.cf lambdaU = Bq.lambdaU # Step 2.a.i: Import derivative expressions for betaU defined in the BSSN.BSSN_quantities module: Bq.betaU_derivs() betaU_dD = Bq.betaU_dD betaU_dDD = Bq.betaU_dDD # Step 2.a.ii: Import derivative expression for gammabarDD Bq.gammabar__inverse_and_derivs() gammabarDD_dupD = Bq.gammabarDD_dupD # Step 2.a.iii: First term of \partial_t \bar{\gamma}_{i j} right-hand side: # \beta^k \bar{\gamma}_{ij,k} + \beta^k_{,i} \bar{\gamma}_{kj} + \beta^k_{,j} \bar{\gamma}_{ik} gammabar_rhsDD = ixp.zerorank2() for i in range(DIM): for j in range(DIM): for k in range(DIM): gammabar_rhsDD[i][j] += betaU[k] * gammabarDD_dupD[i][j][k] + betaU_dD[k][i] * gammabarDD[k][j] \ + betaU_dD[k][j] * gammabarDD[i][k] # Step 2.b.i: First import \bar{A}_{ij} = AbarDD[i][j], and its contraction trAbar = \bar{A}^k_k # from BSSN.BSSN_quantities Bq.AbarUU_AbarUD_trAbar_AbarDD_dD() trAbar = Bq.trAbar # Step 2.b.ii: Import detgammabar quantities from BSSN.BSSN_quantities: Bq.detgammabar_and_derivs() detgammabar = Bq.detgammabar detgammabar_dD = Bq.detgammabar_dD # Step 2.b.ii: Compute the contraction \bar{D}_k \beta^k = \beta^k_{,k} + \frac{\beta^k \bar{\gamma}_{,k}}{2 \bar{\gamma}} Dbarbetacontraction = sp.sympify(0) for k in range(DIM): Dbarbetacontraction += betaU_dD[k][ k] + betaU[k] * detgammabar_dD[k] / (2 * detgammabar) # Step 2.b.iii: Second term of \partial_t \bar{\gamma}_{i j} right-hand side: # \frac{2}{3} \bar{\gamma}_{i j} \left (\alpha \bar{A}_{k}^{k} - \bar{D}_{k} \beta^{k}\right ) for i in range(DIM): for j in range(DIM): gammabar_rhsDD[i][j] += sp.Rational(2, 3) * gammabarDD[i][j] * ( alpha * trAbar - Dbarbetacontraction) # Step 2.c: Third term of \partial_t \bar{\gamma}_{i j} right-hand side: # -2 \alpha \bar{A}_{ij} for i in range(DIM): for j in range(DIM): gammabar_rhsDD[i][j] += -2 * alpha * AbarDD[i][j] # Step 3.a: First term of \partial_t \bar{A}_{i j}: # \beta^k \partial_k \bar{A}_{ij} + \partial_i \beta^k \bar{A}_{kj} + \partial_j \beta^k \bar{A}_{ik} # First define AbarDD_dupD: AbarDD_dupD = Bq.AbarDD_dupD # From Bq.AbarUU_AbarUD_trAbar_AbarDD_dD() Abar_rhsDD = ixp.zerorank2() for i in range(DIM): for j in range(DIM): for k in range(DIM): Abar_rhsDD[i][j] += betaU[k] * AbarDD_dupD[i][j][k] + betaU_dD[k][i] * AbarDD[k][j] \ + betaU_dD[k][j] * AbarDD[i][k] # Step 3.b: Second term of \partial_t \bar{A}_{i j}: # - (2/3) \bar{A}_{i j} \bar{D}_{k} \beta^{k} - 2 \alpha \bar{A}_{i k} {\bar{A}^{k}}_{j} + \alpha \bar{A}_{i j} K gammabarUU = Bq.gammabarUU # From Bq.gammabar__inverse_and_derivs() AbarUD = Bq.AbarUD # From Bq.AbarUU_AbarUD_trAbar() for i in range(DIM): for j in range(DIM): Abar_rhsDD[i][j] += -sp.Rational(2, 3) * AbarDD[i][ j] * Dbarbetacontraction + alpha * AbarDD[i][j] * trK for k in range(DIM): Abar_rhsDD[i][j] += -2 * alpha * AbarDD[i][k] * AbarUD[k][j] # Step 3.c.i: Define partial derivatives of \phi in terms of evolved quantity "cf": Bq.phi_and_derivs() phi_dD = Bq.phi_dD phi_dupD = Bq.phi_dupD phi_dDD = Bq.phi_dDD exp_m4phi = Bq.exp_m4phi phi_dBarD = Bq.phi_dBarD # phi_dBarD = Dbar_i phi = phi_dD (since phi is a scalar) phi_dBarDD = Bq.phi_dBarDD # phi_dBarDD = Dbar_i Dbar_j phi (covariant derivative) # Step 3.c.ii: Define RbarDD Bq.RicciBar__gammabarDD_dHatD__DGammaUDD__DGammaU() RbarDD = Bq.RbarDD # Step 3.c.iii: Define first and second derivatives of \alpha, as well as # \bar{D}_i \bar{D}_j \alpha, which is defined just like phi alpha_dD = ixp.declarerank1("alpha_dD") alpha_dDD = ixp.declarerank2("alpha_dDD", "sym01") alpha_dBarD = alpha_dD alpha_dBarDD = ixp.zerorank2() GammabarUDD = Bq.GammabarUDD # Defined in Bq.gammabar__inverse_and_derivs() for i in range(DIM): for j in range(DIM): alpha_dBarDD[i][j] = alpha_dDD[i][j] for k in range(DIM): alpha_dBarDD[i][j] += -GammabarUDD[k][i][j] * alpha_dD[k] # Step 3.c.iv: Define the terms in curly braces: curlybrackettermsDD = ixp.zerorank2() for i in range(DIM): for j in range(DIM): curlybrackettermsDD[i][j] = -2 * alpha * phi_dBarDD[i][j] + 4 * alpha * phi_dBarD[i] * phi_dBarD[j] \ + 2 * alpha_dBarD[i] * phi_dBarD[j] \ + 2 * alpha_dBarD[j] * phi_dBarD[i] \ - alpha_dBarDD[i][j] + alpha * RbarDD[i][j] # Step 3.c.v: Compute the trace: curlybracketterms_trace = sp.sympify(0) for i in range(DIM): for j in range(DIM): curlybracketterms_trace += gammabarUU[i][j] * curlybrackettermsDD[ i][j] # Step 3.c.vi: Third and final term of Abar_rhsDD[i][j]: for i in range(DIM): for j in range(DIM): Abar_rhsDD[i][j] += exp_m4phi * ( curlybrackettermsDD[i][j] - sp.Rational(1, 3) * gammabarDD[i][j] * curlybracketterms_trace) # Step 4: Right-hand side of conformal factor variable "cf". Supported # options include: cf=phi, cf=W=e^(-2*phi) (default), and cf=chi=e^(-4*phi) # \partial_t phi = \left[\beta^k \partial_k \phi \right] <- TERM 1 # + \frac{1}{6} \left (\bar{D}_{k} \beta^{k} - \alpha K \right ) <- TERM 2 global cf_rhs cf_rhs = sp.Rational(1, 6) * (Dbarbetacontraction - alpha * trK) # Term 2 for k in range(DIM): cf_rhs += betaU[k] * phi_dupD[k] # Term 1 # Next multiply to convert phi_rhs to cf_rhs. if par.parval_from_str( "BSSN.BSSN_quantities::EvolvedConformalFactor_cf") == "phi": pass # do nothing; cf_rhs = phi_rhs elif par.parval_from_str( "BSSN.BSSN_quantities::EvolvedConformalFactor_cf") == "W": cf_rhs *= -2 * cf # cf_rhs = -2*cf*phi_rhs elif par.parval_from_str( "BSSN.BSSN_quantities::EvolvedConformalFactor_cf") == "chi": cf_rhs *= -4 * cf # cf_rhs = -4*cf*phi_rhs else: print("Error: EvolvedConformalFactor_cf == " + par.parval_from_str( "BSSN.BSSN_quantities::EvolvedConformalFactor_cf") + " unsupported!") exit(1) # Step 5: right-hand side of trK (trace of extrinsic curvature): # \partial_t K = \beta^k \partial_k K <- TERM 1 # + \frac{1}{3} \alpha K^{2} <- TERM 2 # + \alpha \bar{A}_{i j} \bar{A}^{i j} <- TERM 3 # - - e^{-4 \phi} (\bar{D}_{i} \bar{D}^{i} \alpha + 2 \bar{D}^{i} \alpha \bar{D}_{i} \phi ) <- TERM 4 global trK_rhs # TERM 2: trK_rhs = sp.Rational(1, 3) * alpha * trK * trK trK_dupD = ixp.declarerank1("trK_dupD") for i in range(DIM): # TERM 1: trK_rhs += betaU[i] * trK_dupD[i] for i in range(DIM): for j in range(DIM): # TERM 4: trK_rhs += -exp_m4phi * gammabarUU[i][j] * ( alpha_dBarDD[i][j] + 2 * alpha_dBarD[j] * phi_dBarD[i]) AbarUU = Bq.AbarUU # From Bq.AbarUU_AbarUD_trAbar() for i in range(DIM): for j in range(DIM): # TERM 3: trK_rhs += alpha * AbarDD[i][j] * AbarUU[i][j] # Step 6: right-hand side of \partial_t \bar{\Lambda}^i: # \partial_t \bar{\Lambda}^i = \beta^k \partial_k \bar{\Lambda}^i - \partial_k \beta^i \bar{\Lambda}^k <- TERM 1 # + \bar{\gamma}^{j k} \hat{D}_{j} \hat{D}_{k} \beta^{i} <- TERM 2 # + \frac{2}{3} \Delta^{i} \bar{D}_{j} \beta^{j} <- TERM 3 # + \frac{1}{3} \bar{D}^{i} \bar{D}_{j} \beta^{j} <- TERM 4 # - 2 \bar{A}^{i j} (\partial_{j} \alpha - 6 \partial_{j} \phi) <- TERM 5 # + 2 \alpha \bar{A}^{j k} \Delta_{j k}^{i} <- TERM 6 # - \frac{4}{3} \alpha \bar{\gamma}^{i j} \partial_{j} K <- TERM 7 # Step 6.a: Term 1 of \partial_t \bar{\Lambda}^i: \beta^k \partial_k \bar{\Lambda}^i - \partial_k \beta^i \bar{\Lambda}^k # First we declare \bar{\Lambda}^i and \bar{\Lambda}^i_{,j} in terms of \lambda^i and \lambda^i_{,j} global LambdabarU_dupD # Used on the RHS of the Gamma-driving shift conditions LambdabarU_dupD = ixp.zerorank2() lambdaU_dupD = ixp.declarerank2("lambdaU_dupD", "nosym") for i in range(DIM): for j in range(DIM): LambdabarU_dupD[i][j] = lambdaU_dupD[i][j] * rfm.ReU[i] + lambdaU[ i] * rfm.ReUdD[i][j] global Lambdabar_rhsU # Used on the RHS of the Gamma-driving shift conditions Lambdabar_rhsU = ixp.zerorank1() for i in range(DIM): for k in range(DIM): Lambdabar_rhsU[i] += betaU[k] * LambdabarU_dupD[i][k] - betaU_dD[ i][k] * LambdabarU[k] # Term 1 # Step 6.b: Term 2 of \partial_t \bar{\Lambda}^i = \bar{\gamma}^{jk} (Term 2a + Term 2b + Term 2c) # Term 2a: \bar{\gamma}^{jk} \beta^i_{,kj} Term2aUDD = ixp.zerorank3() for i in range(DIM): for j in range(DIM): for k in range(DIM): Term2aUDD[i][j][k] += betaU_dDD[i][k][j] # Term 2b: \hat{\Gamma}^i_{mk,j} \beta^m + \hat{\Gamma}^i_{mk} \beta^m_{,j} # + \hat{\Gamma}^i_{dj}\beta^d_{,k} - \hat{\Gamma}^d_{kj} \beta^i_{,d} Term2bUDD = ixp.zerorank3() for i in range(DIM): for j in range(DIM): for k in range(DIM): for m in range(DIM): Term2bUDD[i][j][k] += rfm.GammahatUDDdD[i][m][k][j] * betaU[m] \ + rfm.GammahatUDD[i][m][k] * betaU_dD[m][j] \ + rfm.GammahatUDD[i][m][j] * betaU_dD[m][k] \ - rfm.GammahatUDD[m][k][j] * betaU_dD[i][m] # Term 2c: \hat{\Gamma}^i_{dj}\hat{\Gamma}^d_{mk} \beta^m - \hat{\Gamma}^d_{kj} \hat{\Gamma}^i_{md} \beta^m Term2cUDD = ixp.zerorank3() for i in range(DIM): for j in range(DIM): for k in range(DIM): for m in range(DIM): for d in range(DIM): Term2cUDD[i][j][k] += (rfm.GammahatUDD[i][d][j] * rfm.GammahatUDD[d][m][k] \ - rfm.GammahatUDD[d][k][j] * rfm.GammahatUDD[i][m][d]) * betaU[m] Lambdabar_rhsUpieceU = ixp.zerorank1() # Put it all together to get Term 2: for i in range(DIM): for j in range(DIM): for k in range(DIM): Lambdabar_rhsU[i] += gammabarUU[j][k] * (Term2aUDD[i][j][k] + Term2bUDD[i][j][k] + Term2cUDD[i][j][k]) Lambdabar_rhsUpieceU[i] += gammabarUU[j][k] * ( Term2aUDD[i][j][k] + Term2bUDD[i][j][k] + Term2cUDD[i][j][k]) # Step 6.c: Term 3 of \partial_t \bar{\Lambda}^i: # \frac{2}{3} \Delta^{i} \bar{D}_{j} \beta^{j} DGammaU = Bq.DGammaU # From Bq.RicciBar__gammabarDD_dHatD__DGammaUDD__DGammaU() for i in range(DIM): Lambdabar_rhsU[i] += sp.Rational( 2, 3) * DGammaU[i] * Dbarbetacontraction # Term 3 # Step 6.d: Term 4 of \partial_t \bar{\Lambda}^i: # \frac{1}{3} \bar{D}^{i} \bar{D}_{j} \beta^{j} detgammabar_dDD = Bq.detgammabar_dDD # From Bq.detgammabar_and_derivs() Dbarbetacontraction_dBarD = ixp.zerorank1() for k in range(DIM): for m in range(DIM): Dbarbetacontraction_dBarD[m] += betaU_dDD[k][k][m] + \ (betaU_dD[k][m] * detgammabar_dD[k] + betaU[k] * detgammabar_dDD[k][m]) / (2 * detgammabar) \ - betaU[k] * detgammabar_dD[k] * detgammabar_dD[m] / ( 2 * detgammabar * detgammabar) for i in range(DIM): for m in range(DIM): Lambdabar_rhsU[i] += sp.Rational( 1, 3) * gammabarUU[i][m] * Dbarbetacontraction_dBarD[m] # Step 6.e: Term 5 of \partial_t \bar{\Lambda}^i: # - 2 \bar{A}^{i j} (\partial_{j} \alpha - 6 \alpha \partial_{j} \phi) for i in range(DIM): for j in range(DIM): Lambdabar_rhsU[i] += -2 * AbarUU[i][j] * (alpha_dD[j] - 6 * alpha * phi_dD[j]) # Step 6.f: Term 6 of \partial_t \bar{\Lambda}^i: # 2 \alpha \bar{A}^{j k} \Delta^{i}_{j k} DGammaUDD = Bq.DGammaUDD # From RicciBar__gammabarDD_dHatD__DGammaUDD__DGammaU() for i in range(DIM): for j in range(DIM): for k in range(DIM): Lambdabar_rhsU[ i] += 2 * alpha * AbarUU[j][k] * DGammaUDD[i][j][k] # Step 6.g: Term 7 of \partial_t \bar{\Lambda}^i: # -\frac{4}{3} \alpha \bar{\gamma}^{i j} \partial_{j} K trK_dD = ixp.declarerank1("trK_dD") for i in range(DIM): for j in range(DIM): Lambdabar_rhsU[i] += -sp.Rational( 4, 3) * alpha * gammabarUU[i][j] * trK_dD[j] # Step 7: Rescale the RHS quantities so that the evolved # variables are smooth across coord singularities global h_rhsDD, a_rhsDD, lambda_rhsU h_rhsDD = ixp.zerorank2() a_rhsDD = ixp.zerorank2() lambda_rhsU = ixp.zerorank1() for i in range(DIM): lambda_rhsU[i] = Lambdabar_rhsU[i] / rfm.ReU[i] for j in range(DIM): h_rhsDD[i][j] = gammabar_rhsDD[i][j] / rfm.ReDD[i][j] a_rhsDD[i][j] = Abar_rhsDD[i][j] / rfm.ReDD[i][j]
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 Psi4(specify_tetrad=True): global psi4_im_pt, psi4_re_pt # Step 1.b: 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.c: 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.d: 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 1.e: Set up tetrad vectors if specify_tetrad == True: import BSSN.Psi4_tetrads as BP4t BP4t.Psi4_tetrads() mre4U = BP4t.mre4U mim4U = BP4t.mim4U n4U = BP4t.n4U else: # For code validation against NRPy+ psi_4 tutorial module (Tutorial-Psi4.ipynb); # ensures a more complete code validation. mre4U = ixp.declarerank1("mre4U", DIM=4) mim4U = ixp.declarerank1("mim4U", DIM=4) n4U = ixp.declarerank1("n4U", DIM=4) # Step 2: Construct the (rank-4) Riemann curvature tensor associated with the ADM 3-metric: RDDDD = ixp.zerorank4() gammaDDdDD = AB.gammaDDdDD for i in range(DIM): for k in range(DIM): for l in range(DIM): for m in range(DIM): RDDDD[i][k][l][m] = sp.Rational(1, 2) * \ (gammaDDdDD[i][m][k][l] + gammaDDdDD[k][l][i][m] - gammaDDdDD[i][l][k][m] - gammaDDdDD[k][m][i][l]) # ... then we add the term on the right: gammaDD = AB.gammaDD GammaUDD = AB.GammaUDD for i in range(DIM): for k in range(DIM): for l in range(DIM): for m in range(DIM): for n in range(DIM): for p in range(DIM): RDDDD[i][k][l][m] += gammaDD[n][p] * \ (GammaUDD[n][k][l] * GammaUDD[p][i][m] - GammaUDD[n][k][m] * GammaUDD[p][i][l]) # Step 3: Construct the (rank-4) tensor in term 1 of psi_4 (referring to Eq 5.1 in # Baker, Campanelli, Lousto (2001); https://arxiv.org/pdf/gr-qc/0104063.pdf rank4term1DDDD = ixp.zerorank4() KDD = AB.KDD for i in range(DIM): for j in range(DIM): for k in range(DIM): for l in range(DIM): rank4term1DDDD[i][j][k][l] = RDDDD[i][j][k][ l] + KDD[i][k] * KDD[l][j] - KDD[i][l] * KDD[k][j] # Step 4: Construct the (rank-3) tensor in term 2 of psi_4 (referring to Eq 5.1 in # Baker, Campanelli, Lousto (2001); https://arxiv.org/pdf/gr-qc/0104063.pdf rank3term2DDD = ixp.zerorank3() KDDdD = AB.KDDdD for j in range(DIM): for k in range(DIM): for l in range(DIM): rank3term2DDD[j][k][l] = sp.Rational( 1, 2) * (KDDdD[j][k][l] - KDDdD[j][l][k]) # ... then we construct the second term in this sum: # \Gamma^{p}_{j[k} K_{l]p} = \frac{1}{2} (\Gamma^{p}_{jk} K_{lp}-\Gamma^{p}_{jl} K_{kp}): for j in range(DIM): for k in range(DIM): for l in range(DIM): for p in range(DIM): rank3term2DDD[j][k][l] += sp.Rational( 1, 2) * (GammaUDD[p][j][k] * KDD[l][p] - GammaUDD[p][j][l] * KDD[k][p]) # Finally, we multiply the term by $-8$: for j in range(DIM): for k in range(DIM): for l in range(DIM): rank3term2DDD[j][k][l] *= sp.sympify(-8) # Step 5: Construct the (rank-2) tensor in term 3 of psi_4 (referring to Eq 5.1 in # Baker, Campanelli, Lousto (2001); https://arxiv.org/pdf/gr-qc/0104063.pdf # Step 5.1: Construct 3-Ricci tensor R_{ij} = gamma^{im} R_{ijml} RDD = ixp.zerorank2() gammaUU = AB.gammaUU for j in range(DIM): for l in range(DIM): for i in range(DIM): for m in range(DIM): RDD[j][l] += gammaUU[i][m] * RDDDD[i][j][m][l] # Step 5.2: Construct K^p_l = gamma^{pi} K_{il} KUD = ixp.zerorank2() for p in range(DIM): for l in range(DIM): for i in range(DIM): KUD[p][l] += gammaUU[p][i] * KDD[i][l] # Step 5.3: Construct trK = gamma^{ij} K_{ij} trK = sp.sympify(0) for i in range(DIM): for j in range(DIM): trK += gammaUU[i][j] * KDD[i][j] # Next we put these terms together to construct the entire term in parentheses: # +4 \left(R_{jl} - K_{jp} K^p_l + K K_{jl} \right), rank2term3DD = ixp.zerorank2() for j in range(DIM): for l in range(DIM): rank2term3DD[j][l] = RDD[j][l] + trK * KDD[j][l] for p in range(DIM): rank2term3DD[j][l] += -KDD[j][p] * KUD[p][l] # Finally we multiply by +4: for j in range(DIM): for l in range(DIM): rank2term3DD[j][l] *= sp.sympify(4) # Step 6: Construct real & imaginary parts of psi_4 # by contracting constituent rank 2, 3, and 4 # tensors with input tetrads mre4U, mim4U, & n4U. def tetrad_product__Real_psi4(n, Mre, Mim, mu, nu, eta, delta): return +n[mu] * Mre[nu] * n[eta] * Mre[delta] - n[mu] * Mim[nu] * n[ eta] * Mim[delta] def tetrad_product__Imag_psi4(n, Mre, Mim, mu, nu, eta, delta): return -n[mu] * Mre[nu] * n[eta] * Mim[delta] - n[mu] * Mim[nu] * n[ eta] * Mre[delta] # We split psi_4 into three pieces, to expedite & possibly parallelize C code generation. psi4_re_pt = [sp.sympify(0), sp.sympify(0), sp.sympify(0)] psi4_im_pt = [sp.sympify(0), sp.sympify(0), sp.sympify(0)] # First term: for i in range(DIM): for j in range(DIM): for k in range(DIM): for l in range(DIM): psi4_re_pt[0] += rank4term1DDDD[i][j][ k][l] * tetrad_product__Real_psi4( n4U, mre4U, mim4U, i + 1, j + 1, k + 1, l + 1) psi4_im_pt[0] += rank4term1DDDD[i][j][ k][l] * tetrad_product__Imag_psi4( n4U, mre4U, mim4U, i + 1, j + 1, k + 1, l + 1) # Second term: for j in range(DIM): for k in range(DIM): for l in range(DIM): psi4_re_pt[1] += rank3term2DDD[j][k][l] * \ sp.Rational(1, 2) * (+tetrad_product__Real_psi4(n4U, mre4U, mim4U, 0, j + 1, k + 1, l + 1) - tetrad_product__Real_psi4(n4U, mre4U, mim4U, j + 1, 0, k + 1, l + 1)) psi4_im_pt[1] += rank3term2DDD[j][k][l] * \ sp.Rational(1, 2) * (+tetrad_product__Imag_psi4(n4U, mre4U, mim4U, 0, j + 1, k + 1, l + 1) - tetrad_product__Imag_psi4(n4U, mre4U, mim4U, j + 1, 0, k + 1, l + 1)) # Third term: for j in range(DIM): for l in range(DIM): psi4_re_pt[2] += rank2term3DD[j][l] * \ (sp.Rational(1, 4) * (+tetrad_product__Real_psi4(n4U, mre4U, mim4U, 0, j + 1, 0, l + 1) - tetrad_product__Real_psi4(n4U, mre4U, mim4U, j + 1, 0, 0, l + 1) - tetrad_product__Real_psi4(n4U, mre4U, mim4U, 0, j + 1, l + 1, 0) + tetrad_product__Real_psi4(n4U, mre4U, mim4U, j + 1, 0, l + 1, 0))) psi4_im_pt[2] += rank2term3DD[j][l] * \ (sp.Rational(1, 4) * (+tetrad_product__Imag_psi4(n4U, mre4U, mim4U, 0, j + 1, 0, l + 1) - tetrad_product__Imag_psi4(n4U, mre4U, mim4U, j + 1, 0, 0, l + 1) - tetrad_product__Imag_psi4(n4U, mre4U, mim4U, 0, j + 1, l + 1, 0) + tetrad_product__Imag_psi4(n4U, mre4U, mim4U, j + 1, 0, l + 1, 0)))
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 GiRaFFE_NRPy_Main_Driver_generate_all(out_dir): cmd.mkdir(out_dir) gammaDD = ixp.register_gridfunctions_for_single_rank2("AUXEVOL", "gammaDD", "sym01", DIM=3) betaU = ixp.register_gridfunctions_for_single_rank1("AUXEVOL", "betaU", DIM=3) alpha = gri.register_gridfunctions("AUXEVOL", "alpha") AD = ixp.register_gridfunctions_for_single_rank1("EVOL", "AD") BU = ixp.register_gridfunctions_for_single_rank1("AUXEVOL", "BU") ValenciavU = ixp.register_gridfunctions_for_single_rank1( "AUXEVOL", "ValenciavU") psi6Phi = gri.register_gridfunctions("EVOL", "psi6Phi") StildeD = ixp.register_gridfunctions_for_single_rank1("EVOL", "StildeD") ixp.register_gridfunctions_for_single_rank1("AUXEVOL", "PhievolParenU", DIM=3) gri.register_gridfunctions("AUXEVOL", "AevolParen") # Declare this symbol: sqrt4pi = par.Cparameters("REAL", thismodule, "sqrt4pi", "sqrt(4.0*M_PI)") GRHD.compute_sqrtgammaDET(gammaDD) GRFFE.compute_AD_source_term_operand_for_FD(GRHD.sqrtgammaDET, betaU, alpha, psi6Phi, AD) GRFFE.compute_psi6Phi_rhs_flux_term_operand(gammaDD, GRHD.sqrtgammaDET, betaU, alpha, AD, psi6Phi) parens_to_print = [\ lhrh(lhs=gri.gfaccess("auxevol_gfs","AevolParen"),rhs=GRFFE.AevolParen),\ lhrh(lhs=gri.gfaccess("auxevol_gfs","PhievolParenU0"),rhs=GRFFE.PhievolParenU[0]),\ lhrh(lhs=gri.gfaccess("auxevol_gfs","PhievolParenU1"),rhs=GRFFE.PhievolParenU[1]),\ lhrh(lhs=gri.gfaccess("auxevol_gfs","PhievolParenU2"),rhs=GRFFE.PhievolParenU[2]),\ ] subdir = "RHSs" cmd.mkdir(os.path.join(out_dir, subdir)) desc = "Calculate quantities to be finite-differenced for the GRFFE RHSs" name = "calculate_AD_gauge_term_psi6Phi_flux_term_for_RHSs" outCfunction( outfile=os.path.join(out_dir, subdir, name + ".h"), desc=desc, name=name, params= "const paramstruct *restrict params,const REAL *restrict in_gfs,REAL *restrict auxevol_gfs", body=fin.FD_outputC("returnstring", parens_to_print, params=outCparams).replace("IDX4", "IDX4S"), loopopts="AllPoints", rel_path_for_Cparams=os.path.join("../")) xi_damping = par.Cparameters("REAL", thismodule, "xi_damping", 0.1) GRFFE.compute_psi6Phi_rhs_damping_term(alpha, psi6Phi, xi_damping) AevolParen_dD = ixp.declarerank1("AevolParen_dD", DIM=3) PhievolParenU_dD = ixp.declarerank2("PhievolParenU_dD", "nosym", DIM=3) A_rhsD = ixp.zerorank1() psi6Phi_rhs = GRFFE.psi6Phi_damping for i in range(3): A_rhsD[i] += -AevolParen_dD[i] psi6Phi_rhs += -PhievolParenU_dD[i][i] # Add Kreiss-Oliger dissipation to the GRFFE RHSs: # psi6Phi_dKOD = ixp.declarerank1("psi6Phi_dKOD") # AD_dKOD = ixp.declarerank2("AD_dKOD","nosym") # for i in range(3): # psi6Phi_rhs += diss_strength*psi6Phi_dKOD[i]*rfm.ReU[i] # ReU[i] = 1/scalefactor_orthog_funcform[i] # for j in range(3): # A_rhsD[j] += diss_strength*AD_dKOD[j][i]*rfm.ReU[i] # ReU[i] = 1/scalefactor_orthog_funcform[i] RHSs_to_print = [\ lhrh(lhs=gri.gfaccess("rhs_gfs","AD0"),rhs=A_rhsD[0]),\ lhrh(lhs=gri.gfaccess("rhs_gfs","AD1"),rhs=A_rhsD[1]),\ lhrh(lhs=gri.gfaccess("rhs_gfs","AD2"),rhs=A_rhsD[2]),\ lhrh(lhs=gri.gfaccess("rhs_gfs","psi6Phi"),rhs=psi6Phi_rhs),\ ] desc = "Calculate AD gauge term and psi6Phi RHSs" name = "calculate_AD_gauge_psi6Phi_RHSs" source_Ccode = outCfunction( outfile="returnstring", desc=desc, name=name, params= "const paramstruct *params,const REAL *in_gfs,const REAL *auxevol_gfs,REAL *rhs_gfs", body=fin.FD_outputC("returnstring", RHSs_to_print, params=outCparams).replace("IDX4", "IDX4S"), loopopts="InteriorPoints", rel_path_for_Cparams=os.path.join("../")).replace( "= NGHOSTS", "= NGHOSTS_A2B").replace( "NGHOSTS+Nxx0", "Nxx_plus_2NGHOSTS0-NGHOSTS_A2B").replace( "NGHOSTS+Nxx1", "Nxx_plus_2NGHOSTS1-NGHOSTS_A2B").replace( "NGHOSTS+Nxx2", "Nxx_plus_2NGHOSTS2-NGHOSTS_A2B") # Note the above .replace() functions. These serve to expand the loop range into the ghostzones, since # the second-order FD needs fewer than some other algorithms we use do. with open(os.path.join(out_dir, subdir, name + ".h"), "w") as file: file.write(source_Ccode) source.write_out_functions_for_StildeD_source_term( os.path.join(out_dir, subdir), outCparams, gammaDD, betaU, alpha, ValenciavU, BU, sqrt4pi) subdir = "FCVAL" cmd.mkdir(os.path.join(out_dir, subdir)) FCVAL.GiRaFFE_NRPy_FCVAL(os.path.join(out_dir, subdir)) subdir = "PPM" cmd.mkdir(os.path.join(out_dir, subdir)) PPM.GiRaFFE_NRPy_PPM(os.path.join(out_dir, subdir)) # We will pass values of the gridfunction on the cell faces into the function. This requires us # to declare them as C parameters in NRPy+. We will denote this with the _face infix/suffix. alpha_face = gri.register_gridfunctions("AUXEVOL", "alpha_face") gamma_faceDD = ixp.register_gridfunctions_for_single_rank2( "AUXEVOL", "gamma_faceDD", "sym01") beta_faceU = ixp.register_gridfunctions_for_single_rank1( "AUXEVOL", "beta_faceU") # We'll need some more gridfunctions, now, to represent the reconstructions of BU and ValenciavU # on the right and left faces Valenciav_rU = ixp.register_gridfunctions_for_single_rank1("AUXEVOL", "Valenciav_rU", DIM=3) B_rU = ixp.register_gridfunctions_for_single_rank1("AUXEVOL", "B_rU", DIM=3) Valenciav_lU = ixp.register_gridfunctions_for_single_rank1("AUXEVOL", "Valenciav_lU", DIM=3) B_lU = ixp.register_gridfunctions_for_single_rank1("AUXEVOL", "B_lU", DIM=3) subdir = "RHSs" Af.GiRaFFE_NRPy_Afield_flux(os.path.join(out_dir, subdir)) Sf.generate_C_code_for_Stilde_flux(os.path.join(out_dir, subdir), True, alpha_face, gamma_faceDD, beta_faceU, Valenciav_rU, B_rU, Valenciav_lU, B_lU, sqrt4pi) subdir = "boundary_conditions" cmd.mkdir(os.path.join(out_dir, subdir)) BC.GiRaFFE_NRPy_BCs(os.path.join(out_dir, subdir)) subdir = "A2B" cmd.mkdir(os.path.join(out_dir, subdir)) A2B.GiRaFFE_NRPy_A2B(os.path.join(out_dir, subdir), gammaDD, AD, BU) C2P_P2C.GiRaFFE_NRPy_C2P(StildeD, BU, gammaDD, betaU, alpha) values_to_print = [\ lhrh(lhs=gri.gfaccess("in_gfs","StildeD0"),rhs=C2P_P2C.outStildeD[0]),\ lhrh(lhs=gri.gfaccess("in_gfs","StildeD1"),rhs=C2P_P2C.outStildeD[1]),\ lhrh(lhs=gri.gfaccess("in_gfs","StildeD2"),rhs=C2P_P2C.outStildeD[2]),\ lhrh(lhs=gri.gfaccess("auxevol_gfs","ValenciavU0"),rhs=C2P_P2C.ValenciavU[0]),\ lhrh(lhs=gri.gfaccess("auxevol_gfs","ValenciavU1"),rhs=C2P_P2C.ValenciavU[1]),\ lhrh(lhs=gri.gfaccess("auxevol_gfs","ValenciavU2"),rhs=C2P_P2C.ValenciavU[2])\ ] subdir = "C2P" cmd.mkdir(os.path.join(out_dir, subdir)) desc = "Apply fixes to \tilde{S}_i and recompute the velocity to match with current sheet prescription." name = "GiRaFFE_NRPy_cons_to_prims" outCfunction( outfile=os.path.join(out_dir, subdir, name + ".h"), desc=desc, name=name, params= "const paramstruct *params,REAL *xx[3],REAL *auxevol_gfs,REAL *in_gfs", body=fin.FD_outputC("returnstring", values_to_print, params=outCparams).replace("IDX4", "IDX4S"), loopopts="AllPoints,Read_xxs", rel_path_for_Cparams=os.path.join("../")) C2P_P2C.GiRaFFE_NRPy_P2C(gammaDD, betaU, alpha, ValenciavU, BU, sqrt4pi) values_to_print = [\ lhrh(lhs=gri.gfaccess("in_gfs","StildeD0"),rhs=C2P_P2C.StildeD[0]),\ lhrh(lhs=gri.gfaccess("in_gfs","StildeD1"),rhs=C2P_P2C.StildeD[1]),\ lhrh(lhs=gri.gfaccess("in_gfs","StildeD2"),rhs=C2P_P2C.StildeD[2]),\ ] desc = "Recompute StildeD after current sheet fix to Valencia 3-velocity to ensure consistency between conservative & primitive variables." name = "GiRaFFE_NRPy_prims_to_cons" outCfunction( outfile=os.path.join(out_dir, subdir, name + ".h"), desc=desc, name=name, params="const paramstruct *params,REAL *auxevol_gfs,REAL *in_gfs", body=fin.FD_outputC("returnstring", values_to_print, params=outCparams).replace("IDX4", "IDX4S"), loopopts="AllPoints", rel_path_for_Cparams=os.path.join("../")) # Write out the main driver itself: with open(os.path.join(out_dir, "GiRaFFE_NRPy_Main_Driver.h"), "w") as file: file.write(r"""// Structure to track ghostzones for PPM: typedef struct __gf_and_gz_struct__ { REAL *gf; int gz_lo[4],gz_hi[4]; } gf_and_gz_struct; // Some additional constants needed for PPM: const int VX=0,VY=1,VZ=2,BX=3,BY=4,BZ=5; const int NUM_RECONSTRUCT_GFS = 6; // Include ALL functions needed for evolution #include "RHSs/calculate_AD_gauge_term_psi6Phi_flux_term_for_RHSs.h" #include "RHSs/calculate_AD_gauge_psi6Phi_RHSs.h" #include "PPM/reconstruct_set_of_prims_PPM_GRFFE_NRPy.c" #include "FCVAL/interpolate_metric_gfs_to_cell_faces.h" #include "RHSs/calculate_StildeD0_source_term.h" #include "RHSs/calculate_StildeD1_source_term.h" #include "RHSs/calculate_StildeD2_source_term.h" #include "../calculate_E_field_flat_all_in_one.h" #include "RHSs/calculate_Stilde_flux_D0.h" #include "RHSs/calculate_Stilde_flux_D1.h" #include "RHSs/calculate_Stilde_flux_D2.h" #include "boundary_conditions/GiRaFFE_boundary_conditions.h" #include "A2B/driver_AtoB.h" #include "C2P/GiRaFFE_NRPy_cons_to_prims.h" #include "C2P/GiRaFFE_NRPy_prims_to_cons.h" void override_BU_with_old_GiRaFFE(const paramstruct *restrict params,REAL *restrict auxevol_gfs,const int n) { #include "set_Cparameters.h" char filename[100]; sprintf(filename,"BU0_override-%08d.bin",n); FILE *out2D = fopen(filename, "rb"); fread(auxevol_gfs+BU0GF*Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2, sizeof(double),Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2,out2D); fclose(out2D); sprintf(filename,"BU1_override-%08d.bin",n); out2D = fopen(filename, "rb"); fread(auxevol_gfs+BU1GF*Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2, sizeof(double),Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2,out2D); fclose(out2D); sprintf(filename,"BU2_override-%08d.bin",n); out2D = fopen(filename, "rb"); fread(auxevol_gfs+BU2GF*Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2, sizeof(double),Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2,out2D); fclose(out2D); } void GiRaFFE_NRPy_RHSs(const paramstruct *restrict params,REAL *restrict auxevol_gfs,const REAL *restrict in_gfs,REAL *restrict rhs_gfs) { #include "set_Cparameters.h" // First thing's first: initialize the RHSs to zero! #pragma omp parallel for for(int ii=0;ii<Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2*NUM_EVOL_GFS;ii++) { rhs_gfs[ii] = 0.0; } // Next calculate the easier source terms that don't require flux directions // This will also reset the RHSs for each gf at each new timestep. calculate_AD_gauge_term_psi6Phi_flux_term_for_RHSs(params,in_gfs,auxevol_gfs); calculate_AD_gauge_psi6Phi_RHSs(params,in_gfs,auxevol_gfs,rhs_gfs); // Now, we set up a bunch of structs of pointers to properly guide the PPM algorithm. // They also count the number of ghostzones available. gf_and_gz_struct in_prims[NUM_RECONSTRUCT_GFS], out_prims_r[NUM_RECONSTRUCT_GFS], out_prims_l[NUM_RECONSTRUCT_GFS]; int which_prims_to_reconstruct[NUM_RECONSTRUCT_GFS],num_prims_to_reconstruct; const int Nxxp2NG012 = Nxx_plus_2NGHOSTS0*Nxx_plus_2NGHOSTS1*Nxx_plus_2NGHOSTS2; REAL *temporary = auxevol_gfs + Nxxp2NG012*AEVOLPARENGF; //We're not using this anymore // This sets pointers to the portion of auxevol_gfs containing the relevant gridfunction. int ww=0; in_prims[ww].gf = auxevol_gfs + Nxxp2NG012*VALENCIAVU0GF; out_prims_r[ww].gf = auxevol_gfs + Nxxp2NG012*VALENCIAV_RU0GF; out_prims_l[ww].gf = auxevol_gfs + Nxxp2NG012*VALENCIAV_LU0GF; ww++; in_prims[ww].gf = auxevol_gfs + Nxxp2NG012*VALENCIAVU1GF; out_prims_r[ww].gf = auxevol_gfs + Nxxp2NG012*VALENCIAV_RU1GF; out_prims_l[ww].gf = auxevol_gfs + Nxxp2NG012*VALENCIAV_LU1GF; ww++; in_prims[ww].gf = auxevol_gfs + Nxxp2NG012*VALENCIAVU2GF; out_prims_r[ww].gf = auxevol_gfs + Nxxp2NG012*VALENCIAV_RU2GF; out_prims_l[ww].gf = auxevol_gfs + Nxxp2NG012*VALENCIAV_LU2GF; ww++; in_prims[ww].gf = auxevol_gfs + Nxxp2NG012*BU0GF; out_prims_r[ww].gf = auxevol_gfs + Nxxp2NG012*B_RU0GF; out_prims_l[ww].gf = auxevol_gfs + Nxxp2NG012*B_LU0GF; ww++; in_prims[ww].gf = auxevol_gfs + Nxxp2NG012*BU1GF; out_prims_r[ww].gf = auxevol_gfs + Nxxp2NG012*B_RU1GF; out_prims_l[ww].gf = auxevol_gfs + Nxxp2NG012*B_LU1GF; ww++; in_prims[ww].gf = auxevol_gfs + Nxxp2NG012*BU2GF; out_prims_r[ww].gf = auxevol_gfs + Nxxp2NG012*B_RU2GF; out_prims_l[ww].gf = auxevol_gfs + Nxxp2NG012*B_LU2GF; ww++; // Prims are defined AT ALL GRIDPOINTS, so we set the # of ghostzones to zero: for(int i=0;i<NUM_RECONSTRUCT_GFS;i++) for(int j=1;j<=3;j++) { in_prims[i].gz_lo[j]=0; in_prims[i].gz_hi[j]=0; } // Left/right variables are not yet defined, yet we set the # of gz's to zero by default: for(int i=0;i<NUM_RECONSTRUCT_GFS;i++) for(int j=1;j<=3;j++) { out_prims_r[i].gz_lo[j]=0; out_prims_r[i].gz_hi[j]=0; } for(int i=0;i<NUM_RECONSTRUCT_GFS;i++) for(int j=1;j<=3;j++) { out_prims_l[i].gz_lo[j]=0; out_prims_l[i].gz_hi[j]=0; } ww=0; which_prims_to_reconstruct[ww]=VX; ww++; which_prims_to_reconstruct[ww]=VY; ww++; which_prims_to_reconstruct[ww]=VZ; ww++; which_prims_to_reconstruct[ww]=BX; ww++; which_prims_to_reconstruct[ww]=BY; ww++; which_prims_to_reconstruct[ww]=BZ; ww++; num_prims_to_reconstruct=ww; // In each direction, perform the PPM reconstruction procedure. // Then, add the fluxes to the RHS as appropriate. for(int flux_dirn=0;flux_dirn<3;flux_dirn++) { // In each direction, interpolate the metric gfs (gamma,beta,alpha) to cell faces. interpolate_metric_gfs_to_cell_faces(params,auxevol_gfs,flux_dirn+1); // Then, reconstruct the primitive variables on the cell faces. // This function is housed in the file: "reconstruct_set_of_prims_PPM_GRFFE_NRPy.c" reconstruct_set_of_prims_PPM_GRFFE_NRPy(params, auxevol_gfs, flux_dirn+1, num_prims_to_reconstruct, which_prims_to_reconstruct, in_prims, out_prims_r, out_prims_l, temporary); // For example, if flux_dirn==0, then at gamma_faceDD00(i,j,k) represents gamma_{xx} // at (i-1/2,j,k), Valenciav_lU0(i,j,k) is the x-component of the velocity at (i-1/2-epsilon,j,k), // and Valenciav_rU0(i,j,k) is the x-component of the velocity at (i-1/2+epsilon,j,k). if(flux_dirn==0) { // Next, we calculate the source term for StildeD. Again, this also resets the rhs_gfs array at // each new timestep. calculate_StildeD0_source_term(params,auxevol_gfs,rhs_gfs); // Now, compute the electric field on each face of a cell and add it to the RHSs as appropriate //calculate_E_field_D0_right(params,auxevol_gfs,rhs_gfs); //calculate_E_field_D0_left(params,auxevol_gfs,rhs_gfs); // Finally, we calculate the flux of StildeD and add the appropriate finite-differences // to the RHSs. calculate_Stilde_flux_D0(params,auxevol_gfs,rhs_gfs); } else if(flux_dirn==1) { calculate_StildeD1_source_term(params,auxevol_gfs,rhs_gfs); //calculate_E_field_D1_right(params,auxevol_gfs,rhs_gfs); //calculate_E_field_D1_left(params,auxevol_gfs,rhs_gfs); calculate_Stilde_flux_D1(params,auxevol_gfs,rhs_gfs); } else { calculate_StildeD2_source_term(params,auxevol_gfs,rhs_gfs); //calculate_E_field_D2_right(params,auxevol_gfs,rhs_gfs); //calculate_E_field_D2_left(params,auxevol_gfs,rhs_gfs); calculate_Stilde_flux_D2(params,auxevol_gfs,rhs_gfs); } for(int count=0;count<=1;count++) { // This function is written to be general, using notation that matches the forward permutation added to AD2, // i.e., [F_HLL^x(B^y)]_z corresponding to flux_dirn=0, count=1. // The SIGN parameter is necessary because // -E_z(x_i,y_j,z_k) = 0.25 ( [F_HLL^x(B^y)]_z(i+1/2,j,k)+[F_HLL^x(B^y)]_z(i-1/2,j,k) // -[F_HLL^y(B^x)]_z(i,j+1/2,k)-[F_HLL^y(B^x)]_z(i,j-1/2,k) ) // Note the negative signs on the reversed permutation terms! // By cyclically permuting with flux_dirn, we // get contributions to the other components, and by incrementing count, we get the backward permutations: // Let's suppose flux_dirn = 0. Then we will need to update Ay (count=0) and Az (count=1): // flux_dirn=count=0 -> AD0GF+(flux_dirn+1+count)%3 = AD0GF + (0+1+0)%3=AD1GF <- Updating Ay! // (flux_dirn)%3 = (0)%3 = 0 Vx // (flux_dirn-count+2)%3 = (0-0+2)%3 = 2 Vz . Inputs Vx, Vz -> SIGN = -1 ; 2.0*((REAL)count)-1.0=-1 check! // flux_dirn=0,count=1 -> AD0GF+(flux_dirn+1+count)%3 = AD0GF + (0+1+1)%3=AD2GF <- Updating Az! // (flux_dirn)%3 = (0)%3 = 0 Vx // (flux_dirn-count+2)%3 = (0-1+2)%3 = 1 Vy . Inputs Vx, Vy -> SIGN = +1 ; 2.0*((REAL)count)-1.0=2-1=+1 check! // Let's suppose flux_dirn = 1. Then we will need to update Az (count=0) and Ax (count=1): // flux_dirn=1,count=0 -> AD0GF+(flux_dirn+1+count)%3 = AD0GF + (1+1+0)%3=AD2GF <- Updating Az! // (flux_dirn)%3 = (1)%3 = 1 Vy // (flux_dirn-count+2)%3 = (1-0+2)%3 = 0 Vx . Inputs Vy, Vx -> SIGN = -1 ; 2.0*((REAL)count)-1.0=-1 check! // flux_dirn=count=1 -> AD0GF+(flux_dirn+1+count)%3 = AD0GF + (1+1+1)%3=AD0GF <- Updating Ax! // (flux_dirn)%3 = (1)%3 = 1 Vy // (flux_dirn-count+2)%3 = (1-1+2)%3 = 2 Vz . Inputs Vy, Vz -> SIGN = +1 ; 2.0*((REAL)count)-1.0=2-1=+1 check! // Let's suppose flux_dirn = 2. Then we will need to update Ax (count=0) and Ay (count=1): // flux_dirn=2,count=0 -> AD0GF+(flux_dirn+1+count)%3 = AD0GF + (2+1+0)%3=AD0GF <- Updating Ax! // (flux_dirn)%3 = (2)%3 = 2 Vz // (flux_dirn-count+2)%3 = (2-0+2)%3 = 1 Vy . Inputs Vz, Vy -> SIGN = -1 ; 2.0*((REAL)count)-1.0=-1 check! // flux_dirn=2,count=1 -> AD0GF+(flux_dirn+1+count)%3 = AD0GF + (2+1+1)%3=AD1GF <- Updating Ay! // (flux_dirn)%3 = (2)%3 = 2 Vz // (flux_dirn-count+2)%3 = (2-1+2)%3 = 0 Vx . Inputs Vz, Vx -> SIGN = +1 ; 2.0*((REAL)count)-1.0=2-1=+1 check! calculate_E_field_flat_all_in_one(params, &auxevol_gfs[IDX4ptS(VALENCIAV_RU0GF+(flux_dirn)%3, 0)],&auxevol_gfs[IDX4ptS(VALENCIAV_RU0GF+(flux_dirn-count+2)%3, 0)], &auxevol_gfs[IDX4ptS(VALENCIAV_LU0GF+(flux_dirn)%3, 0)],&auxevol_gfs[IDX4ptS(VALENCIAV_LU0GF+(flux_dirn-count+2)%3, 0)], &auxevol_gfs[IDX4ptS(B_RU0GF +(flux_dirn)%3, 0)],&auxevol_gfs[IDX4ptS(B_RU0GF +(flux_dirn-count+2)%3, 0)], &auxevol_gfs[IDX4ptS(B_LU0GF +(flux_dirn)%3, 0)],&auxevol_gfs[IDX4ptS(B_LU0GF +(flux_dirn-count+2)%3, 0)], &auxevol_gfs[IDX4ptS(B_RU0GF +(flux_dirn-count+2)%3, 0)], &auxevol_gfs[IDX4ptS(B_LU0GF +(flux_dirn-count+2)%3, 0)], &rhs_gfs[IDX4ptS(AD0GF+(flux_dirn+1+count)%3,0)], 2.0*((REAL)count)-1.0, flux_dirn); } } } void GiRaFFE_NRPy_post_step(const paramstruct *restrict params,REAL *xx[3],REAL *restrict auxevol_gfs,REAL *restrict evol_gfs,const int n) { // First, apply BCs to AD and psi6Phi. Then calculate BU from AD apply_bcs_potential(params,evol_gfs); driver_A_to_B(params,evol_gfs,auxevol_gfs); //override_BU_with_old_GiRaFFE(params,auxevol_gfs,n); // Apply fixes to StildeD, then recompute the velocity at the new timestep. // Apply the current sheet prescription to the velocities GiRaFFE_NRPy_cons_to_prims(params,xx,auxevol_gfs,evol_gfs); // Then, recompute StildeD to be consistent with the new velocities //GiRaFFE_NRPy_prims_to_cons(params,auxevol_gfs,evol_gfs); // Finally, apply outflow boundary conditions to the velocities. apply_bcs_velocity(params,auxevol_gfs); } """)
def ScalarField_RHSs(): # Step B.4: 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 B.5: Import all basic (unrescaled) BSSN scalars & tensors Bq.BSSN_basic_tensors() trK = Bq.trK alpha = Bq.alpha betaU = Bq.betaU Bq.gammabar__inverse_and_derivs() gammabarUU = Bq.gammabarUU global sf_rhs, sfM_rhs # Step B.5.a: Declare grid functions for varphi and Pi sf, sfM = sfgfs.declare_scalar_field_gridfunctions_if_not_declared_already( ) # Step 2.a: Add Term 1 to sf_rhs: -alpha*Pi sf_rhs = -alpha * sfM # Step 2.b: Add Term 2 to sf_rhs: beta^{i}\partial_{i}\varphi sf_dupD = ixp.declarerank1("sf_dupD") for i in range(DIM): sf_rhs += betaU[i] * sf_dupD[i] # Step 3a: Add Term 1 to sfM_rhs: alpha * K * Pi sfM_rhs = alpha * trK * sfM # Step 3b: Add Term 2 to sfM_rhs: beta^{i}\partial_{i}Pi sfM_dupD = ixp.declarerank1("sfM_dupD") for i in range(DIM): sfM_rhs += betaU[i] * sfM_dupD[i] # Step 3c: Adding Term 3 to sfM_rhs # Step 3c.i: Term 3a: gammabar^{ij}\partial_{i}\alpha\partial_{j}\varphi alpha_dD = ixp.declarerank1("alpha_dD") sf_dD = ixp.declarerank1("sf_dD") sfMrhsTerm3 = sp.sympify(0) for i in range(DIM): for j in range(DIM): sfMrhsTerm3 += -gammabarUU[i][j] * alpha_dD[i] * sf_dD[j] # Step 3c.ii: Term 3b: \alpha*gammabar^{ij}\partial_{i}\partial_{j}\varphi sf_dDD = ixp.declarerank2("sf_dDD", "sym01") for i in range(DIM): for j in range(DIM): sfMrhsTerm3 += -alpha * gammabarUU[i][j] * sf_dDD[i][j] # Step 3c.iii: Term 3c: 2*alpha*gammabar^{ij}\partial_{j}\varphi\partial_{i}\phi Bq.phi_and_derivs( ) # sets exp^{-4phi} = exp_m4phi and \partial_{i}phi = phi_dD[i] for i in range(DIM): for j in range(DIM): sfMrhsTerm3 += -2 * alpha * gammabarUU[i][j] * sf_dD[ j] * Bq.phi_dD[i] # Step 3c.iv: Multiplying Term 3 by e^{-4phi} and adding it to sfM_rhs sfMrhsTerm3 *= Bq.exp_m4phi sfM_rhs += sfMrhsTerm3 # Step 3d: Adding Term 4 to sfM_rhs # Step 3d.i: Term 4a: \alpha \bar\Lambda^{i}\partial_{i}\varphi LambdabarU = Bq.LambdabarU sfMrhsTerm4 = sp.sympify(0) for i in range(DIM): sfMrhsTerm4 += alpha * LambdabarU[i] * sf_dD[i] # Step 3d.ii: Evaluating \bar\gamma^{ij}\hat\Gamma^{k}_{ij} GammahatUDD = rfm.GammahatUDD gammabarGammahatContractionU = ixp.zerorank1() for k in range(DIM): for i in range(DIM): for j in range(DIM): gammabarGammahatContractionU[ k] += gammabarUU[i][j] * GammahatUDD[k][i][j] # Step 3d.iii: Term 4b: \alpha \bar\gamma^{ij}\hat\Gamma^{k}_{ij}\partial_{k}\varphi for i in range(DIM): sfMrhsTerm4 += alpha * gammabarGammahatContractionU[i] * sf_dD[i] # Step 3d.iii: Multplying Term 4 by e^{-4phi} and adding it to sfM_rhs sfMrhsTerm4 *= Bq.exp_m4phi sfM_rhs += sfMrhsTerm4 return
def write_dfdr_function(self, Ccodesdir, fd_order=2): # function to write c code to calculate dfdr term in Sommerfeld boundary condition # Read what # of dimensions being usded DIM = par.parval_from_str("grid::DIM") # Set up the chosen reference metric from chosen coordinate system, set within NRPy+ CoordSystem = par.parval_from_str("reference_metric::CoordSystem") rfm.reference_metric() # Simplifying the results make them easier to interpret. do_simplify = True if "Sinh" in CoordSystem: # Simplification takes too long on Sinh* coordinate systems do_simplify = False # Construct Jacobian matrix, output Jac_dUSph_dDrfmUD[i][j] = \partial x_{Sph}^i / \partial x^j: Jac_dUSph_dDrfmUD = ixp.zerorank2() for i in range(3): for j in range(3): Jac_dUSph_dDrfmUD[i][j] = sp.diff(rfm.xxSph[i], rfm.xx[j]) # Invert Jacobian matrix, output to Jac_dUrfm_dDSphUD. Jac_dUrfm_dDSphUD, dummyDET = ixp.generic_matrix_inverter3x3( Jac_dUSph_dDrfmUD) # Jac_dUrfm_dDSphUD[i][0] stores \partial x^i / \partial r if do_simplify: for i in range(3): Jac_dUrfm_dDSphUD[i][0] = sp.simplify(Jac_dUrfm_dDSphUD[i][0]) # Declare \partial_i f, which is actually computed later on fdD = ixp.declarerank1("fdD") # = [fdD0, fdD1, fdD2] contraction = sp.sympify(0) for i in range(3): contraction += fdD[i] * Jac_dUrfm_dDSphUD[i][0] contraction = sp.simplify(contraction) r_str_and_contraction_str = outputC([rfm.xxSph[0], contraction], ["*_r", "*_partial_i_f"], filename="returnstring", params="includebraces=False") def gen_central_fd_stencil_str(intdirn, fd_order): if fd_order == 2: if intdirn == 0: return "(gfs[IDX4S(which_gf,i0+1,i1,i2)]-gfs[IDX4S(which_gf,i0-1,i1,i2)])*0.5" # Does not include the 1/dx multiplication elif intdirn == 1: return "(gfs[IDX4S(which_gf,i0,i1+1,i2)]-gfs[IDX4S(which_gf,i0,i1-1,i2)])*0.5" # Does not include the 1/dy multiplication elif intdirn == 2: return "(gfs[IDX4S(which_gf,i0,i1,i2+1)]-gfs[IDX4S(which_gf,i0,i1,i2-1)])*0.5" # Does not include the 1/dz multiplication def output_dfdx(intdirn, fd_order): dirn = str(intdirn) dirnp1 = str( (intdirn + 1) % 3 ) # if dirn='0', then we want this to be '1'; '1' then '2'; and '2' then '0' dirnp2 = str( (intdirn + 2) % 3 ) # if dirn='0', then we want this to be '2'; '1' then '0'; and '2' then '1' if fd_order == 2: return """ // On a +x""" + dirn + """ or -x""" + dirn + """ face, do up/down winding as appropriate: if(abs(FACEXi[""" + dirn + """])==1 || i""" + dirn + """+NGHOSTS >= Nxx_plus_2NGHOSTS""" + dirn + """ || i""" + dirn + """-NGHOSTS <= 0) { int8_t SHIFTSTENCIL""" + dirn + """ = FACEXi[""" + dirn + """]; if(i""" + dirn + """+NGHOSTS >= Nxx_plus_2NGHOSTS""" + dirn + """) SHIFTSTENCIL""" + dirn + """ = -1; if(i""" + dirn + """-NGHOSTS <= 0) SHIFTSTENCIL""" + dirn + """ = +1; SHIFTSTENCIL""" + dirnp1 + """ = 0; SHIFTSTENCIL""" + dirnp2 + """ = 0; fdD""" + dirn + """ = SHIFTSTENCIL""" + dirn + """*(-1.5*gfs[IDX4S(which_gf,i0+0*SHIFTSTENCIL0,i1+0*SHIFTSTENCIL1,i2+0*SHIFTSTENCIL2)] +2.*gfs[IDX4S(which_gf,i0+1*SHIFTSTENCIL0,i1+1*SHIFTSTENCIL1,i2+1*SHIFTSTENCIL2)] -0.5*gfs[IDX4S(which_gf,i0+2*SHIFTSTENCIL0,i1+2*SHIFTSTENCIL1,i2+2*SHIFTSTENCIL2)] )*invdx""" + dirn + """; // Not on a +x""" + dirn + """ or -x""" + dirn + """ face, using centered difference: } else { fdD""" + dirn + """ = """ + gen_central_fd_stencil_str( intdirn, 2) + """*invdx""" + dirn + """; } """ else: print("Error: fd_order = " + str(fd_order) + " currently unsupported.") sys.exit(1) contraction_term_func = """ void contraction_term(const paramstruct *restrict params, const int which_gf, const REAL *restrict gfs, REAL *restrict xx[3], const int8_t FACEXi[3], const int i0, const int i1, const int i2, REAL *restrict _r, REAL *restrict _partial_i_f) { #include "RELATIVE_PATH__set_Cparameters.h" /* Header file containing correct #include for set_Cparameters.h; * accounting for the relative path */ // Initialize derivatives to crazy values, to ensure that // we will notice in case they aren't set properly. REAL fdD0=1e100; REAL fdD1=1e100; REAL fdD2=1e100; REAL xx0 = xx[0][i0]; REAL xx1 = xx[1][i1]; REAL xx2 = xx[2][i2]; int8_t SHIFTSTENCIL0; int8_t SHIFTSTENCIL1; int8_t SHIFTSTENCIL2; """ for i in range(DIM): if "fdD" + str(i) in r_str_and_contraction_str: contraction_term_func += output_dfdx(i, fd_order) contraction_term_func += "\n" + r_str_and_contraction_str contraction_term_func += """ } // END contraction_term function """ with open( os.path.join(Ccodesdir, "boundary_conditions/radial_derivative.h"), "w") as file: file.write(contraction_term_func)
def GiRaFFE_NRPy_Afield_flux(Ccodesdir): cmd.mkdir(Ccodesdir) # Write out the code to a file. gammaDD = ixp.declarerank2("gammaDD", "sym01", DIM=3) betaU = ixp.declarerank1("betaU", DIM=3) alpha = sp.sympify("alpha") for flux_dirn in range(3): chsp.find_cmax_cmin(flux_dirn, gammaDD, betaU, alpha) Ccode_kernel = outputC([chsp.cmax, chsp.cmin], ["cmax", "cmin"], "returnstring", params="outCverbose=False,CSE_sorting=none") Ccode_kernel = Ccode_kernel.replace("cmax", "*cmax").replace("cmin", "*cmin") Ccode_kernel = Ccode_kernel.replace("betaU0", "betaUi").replace( "betaU1", "betaUi").replace("betaU2", "betaUi") with open( os.path.join(Ccodesdir, "compute_cmax_cmin_dirn" + str(flux_dirn) + ".h"), "w") as file: file.write(Ccode_kernel) with open(os.path.join(Ccodesdir, "calculate_E_field_flat_all_in_one.h"), "w") as file: file.write( r"""void find_cmax_cmin(const REAL gammaDD00, const REAL gammaDD01, const REAL gammaDD02, const REAL gammaDD11, const REAL gammaDD12, const REAL gammaDD22, const REAL betaUi, const REAL alpha, const int flux_dirn, REAL *cmax, REAL *cmin) { switch(flux_dirn) { case 0: #include "compute_cmax_cmin_dirn0.h" break; case 1: #include "compute_cmax_cmin_dirn1.h" break; case 2: #include "compute_cmax_cmin_dirn2.h" break; default: printf("Invalid parameter flux_dirn!"); *cmax = 1.0/0.0; *cmin = 1.0/0.0; break; } } REAL HLLE_solve(REAL F0B1_r, REAL F0B1_l, REAL U_r, REAL U_l, REAL cmin, REAL cmax) { // Eq. 3.15 of https://epubs.siam.org/doi/abs/10.1137/1025002?journalCode=siread // F_HLLE = (c_min F_R + c_max F_L - c_min c_max (U_R-U_L)) / (c_min + c_max) return (cmin*F0B1_r + cmax*F0B1_l - cmin*cmax*(U_r-U_l)) / (cmin+cmax); } /* Calculate the electric flux on both faces in the input direction. The input count is an integer that is either 0 or 1. If it is 0, this implies that the components are input in order of a backwards permutation and the final results will need to be multiplied by -1.0. If it is 1, then the permutation is forwards. */ void calculate_E_field_flat_all_in_one(const paramstruct *params, const REAL *Vr0,const REAL *Vr1, const REAL *Vl0,const REAL *Vl1, const REAL *Br0,const REAL *Br1, const REAL *Bl0,const REAL *Bl1, const REAL *Brflux_dirn, const REAL *Blflux_dirn, const REAL *gamma_faceDD00, const REAL *gamma_faceDD01, const REAL *gamma_faceDD02, const REAL *gamma_faceDD11, const REAL *gamma_faceDD12, const REAL *gamma_faceDD22, const REAL *beta_faceU0, const REAL *beta_faceU1, const REAL *alpha_face, REAL *A2_rhs,const REAL SIGN,const int flux_dirn) { // This function is written to be generic and compute the contribution for all three AD RHSs. // However, for convenience, the notation used in the function itself is for the contribution // to AD2, specifically the [F_HLL^x(B^y)]_z term, with reconstructions in the x direction. This // corresponds to flux_dirn=0 and count=1 (which corresponds to SIGN=+1.0). // Thus, Az(i,j,k) += 0.25 ( [F_HLL^x(B^y)]_z(i+1/2,j,k)+[F_HLL^x(B^y)]_z(i-1/2,j,k)) are solved here. // The other terms are computed by cyclically permuting the indices when calling this function. #include "../set_Cparameters.h" #pragma omp parallel for for(int i2=NGHOSTS; i2<NGHOSTS+Nxx2; i2++) { for(int i1=NGHOSTS; i1<NGHOSTS+Nxx1; i1++) { for(int i0=NGHOSTS; i0<NGHOSTS+Nxx0; i0++) { // First, we set the index from which we will read memory. indexp1 is incremented by // one point in the direction of reconstruction. These correspond to the faces at at // i-1/2 and i+1/2, respectively. // Now, we read in memory. We need the x and y components of velocity and magnetic field on both // the left and right sides of the interface at *both* faces. // Here, the point (i0,i1,i2) corresponds to the point (i-1/2,j,k) const int index = IDX3S(i0,i1,i2); const double alpha = alpha_face[index]; const double betaU0 = beta_faceU0[index]; const double betaU1 = beta_faceU1[index]; const double v_rU0 = alpha*Vr0[index]-betaU0; const double v_rU1 = alpha*Vr1[index]-betaU1; const double B_rU0 = Br0[index]; const double B_rU1 = Br1[index]; const double B_rflux_dirn = Brflux_dirn[index]; const double v_lU0 = alpha*Vl0[index]-betaU0; const double v_lU1 = alpha*Vl1[index]-betaU1; const double B_lU0 = Bl0[index]; const double B_lU1 = Bl1[index]; const double B_lflux_dirn = Blflux_dirn[index]; // We will also need need the square root of the metric determinant here at this point: const REAL gxx = gamma_faceDD00[index]; const REAL gxy = gamma_faceDD01[index]; const REAL gxz = gamma_faceDD02[index]; const REAL gyy = gamma_faceDD11[index]; const REAL gyz = gamma_faceDD12[index]; const REAL gzz = gamma_faceDD22[index]; const REAL sqrtgammaDET = sqrt( gxx*gyy*gzz - gxx*gyz*gyz +2*gxy*gxz*gyz - gyy*gxz*gxz - gzz*gxy*gxy ); // ******************************* // REPEAT ABOVE, but at i+1, which corresponds to point (i+1/2,j,k) // Recall that the documentation here assumes flux_dirn==0, but the // algorithm is generalized so that any flux_dirn or velocity/magnetic // field component can be computed via permuting the inputs into this // function. const int indexp1 = IDX3S(i0+(flux_dirn==0),i1+(flux_dirn==1),i2+(flux_dirn==2)); const double alpha_p1 = alpha_face[indexp1]; const double betaU0_p1 = beta_faceU0[indexp1]; const double betaU1_p1 = beta_faceU1[indexp1]; const double v_rU0_p1 = alpha_p1*Vr0[indexp1]-betaU0_p1; const double v_rU1_p1 = alpha_p1*Vr1[indexp1]-betaU1_p1; const double B_rU0_p1 = Br0[indexp1]; const double B_rU1_p1 = Br1[indexp1]; const double B_rflux_dirn_p1 = Brflux_dirn[indexp1]; const double v_lU0_p1 = alpha_p1*Vl0[indexp1]-betaU0_p1; const double v_lU1_p1 = alpha_p1*Vl1[indexp1]-betaU1_p1; const double B_lU0_p1 = Bl0[indexp1]; const double B_lU1_p1 = Bl1[indexp1]; const double B_lflux_dirn_p1 = Blflux_dirn[indexp1]; // We will also need need the square root of the metric determinant here at this point: const REAL gxx_p1 = gamma_faceDD00[indexp1]; const REAL gxy_p1 = gamma_faceDD01[indexp1]; const REAL gxz_p1 = gamma_faceDD02[indexp1]; const REAL gyy_p1 = gamma_faceDD11[indexp1]; const REAL gyz_p1 = gamma_faceDD12[indexp1]; const REAL gzz_p1 = gamma_faceDD22[indexp1]; const REAL sqrtgammaDET_p1 = sqrt( gxx_p1*gyy_p1*gzz_p1 - gxx_p1*gyz_p1*gyz_p1 +2*gxy_p1*gxz_p1*gyz_p1 - gyy_p1*gxz_p1*gxz_p1 - gzz_p1*gxy_p1*gxy_p1 ); // ******************************* // DEBUGGING: // if(flux_dirn==0 && SIGN>0 && i1==Nxx_plus_2NGHOSTS1/2 && i2==Nxx_plus_2NGHOSTS2/2) { // printf("index=%d & indexp1=%d\n",index,indexp1); // } // Since we are computing A_z, the relevant equation here is: // -E_z(x_i,y_j,z_k) = 0.25 ( [F_HLL^x(B^y)]_z(i+1/2,j,k)+[F_HLL^x(B^y)]_z(i-1/2,j,k) // -[F_HLL^y(B^x)]_z(i,j+1/2,k)-[F_HLL^y(B^x)]_z(i,j-1/2,k) ) // We will construct the above sum one half at a time, first with SIGN=+1, which // corresponds to flux_dirn = 0, count=1, and // takes care of the terms: // [F_HLL^x(B^y)]_z(i+1/2,j,k)+[F_HLL^x(B^y)]_z(i-1/2,j,k) // ( Note that we will repeat the above with flux_dirn = 1, count = 0, with SIGN=-1 // AND with the input components switched (x->y,y->x) so that we get the term // -[F_HLL^y(B^x)]_z(i,j+1/2,k)-[F_HLL^y(B^x)]_z(i,j-1/2,k) // thus completing the above sum. ) // Here, [F_HLL^i(B^j)]_k = (v^i B^j - v^j B^i) in general. // Calculate the flux vector on each face for each component of the E-field: // The F(B) terms are as Eq. 6 in Giacomazzo: https://arxiv.org/pdf/1009.2468.pdf // [F^i(B^j)]_k = \sqrt{\gamma} (v^i B^j - v^j B^i) // Therefore since we want [F_HLL^x(B^y)]_z, // we will code (v^x B^y - v^y B^x) on both left and right faces. const REAL F0B1_r = sqrtgammaDET*(v_rU0*B_rU1 - v_rU1*B_rU0); const REAL F0B1_l = sqrtgammaDET*(v_lU0*B_lU1 - v_lU1*B_lU0); // Compute the state vector for these terms: const REAL U_r = B_rflux_dirn; const REAL U_l = B_lflux_dirn; REAL cmin,cmax; // Basic HLLE solver: find_cmax_cmin(gxx,gxy,gxz, gyy,gyz,gzz, betaU0,alpha,flux_dirn, &cmax, &cmin); const REAL FHLL_0B1 = HLLE_solve(F0B1_r, F0B1_l, U_r, U_l, cmin, cmax); // ************************************ // ************************************ // REPEAT ABOVE, but at point i+1 // Calculate the flux vector on each face for each component of the E-field: const REAL F0B1_r_p1 = sqrtgammaDET_p1*(v_rU0_p1*B_rU1_p1 - v_rU1_p1*B_rU0_p1); const REAL F0B1_l_p1 = sqrtgammaDET_p1*(v_lU0_p1*B_lU1_p1 - v_lU1_p1*B_lU0_p1); // Compute the state vector for this flux direction const REAL U_r_p1 = B_rflux_dirn_p1; const REAL U_l_p1 = B_lflux_dirn_p1; //const REAL U_r_p1 = B_rU1_p1; //const REAL U_l_p1 = B_lU1_p1; // Basic HLLE solver, but at the next point: find_cmax_cmin(gxx_p1,gxy_p1,gxz_p1, gyy_p1,gyz_p1,gzz_p1, betaU0_p1,alpha_p1,flux_dirn, &cmax, &cmin); const REAL FHLL_0B1p1 = HLLE_solve(F0B1_r_p1, F0B1_l_p1, U_r_p1, U_l_p1, cmin, cmax); // ************************************ // ************************************ // With the Riemann problem solved, we add the contributions to the RHSs: // -E_z(x_i,y_j,z_k) &= 0.25 ( [F_HLL^x(B^y)]_z(i+1/2,j,k)+[F_HLL^x(B^y)]_z(i-1/2,j,k) // -[F_HLL^y(B^x)]_z(i,j+1/2,k)-[F_HLL^y(B^x)]_z(i,j-1/2,k) ) // (Eq. 11 in https://arxiv.org/pdf/1009.2468.pdf) // This code, as written, solves the first two terms for flux_dirn=0. Calling this function for count=0 // and flux_dirn=1 flips x for y to solve the latter two, switching to SIGN=-1 as well. // Here, we finally add together the output of the HLLE solver at i-1/2 and i+1/2 // We also multiply by the SIGN dictated by the order of the input vectors and divide by 4. A2_rhs[index] += SIGN*0.25*(FHLL_0B1 + FHLL_0B1p1); // flux dirn = 0 ===================> i-1/2 i+1/2 // Eq 11 in Giacomazzo: // -FxBy(avg over i-1/2 and i+1/2) + FyBx(avg over j-1/2 and j+1/2) // Eq 6 in Giacomazzo: // FxBy = vxBy - vyBx // -> // FHLL_0B1 = vyBx - vxBy } // END LOOP: for(int i0=NGHOSTS; i0<NGHOSTS+Nxx0; i0++) } // END LOOP: for(int i1=NGHOSTS; i1<NGHOSTS+Nxx1; i1++) } // END LOOP: for(int i2=NGHOSTS; i2<NGHOSTS+Nxx2; i2++) } """)
def BSSN_RHSs__generate_symbolic_expressions(): ###################################### # START: GENERATE SYMBOLIC EXPRESSIONS print("Generating symbolic expressions for BSSN RHSs...") start = time.time() # Enable rfm_precompute infrastructure, which results in # BSSN RHSs that are free of transcendental functions, # even in curvilinear coordinates, so long as # ConformalFactor is set to "W" (default). par.set_parval_from_str("reference_metric::enable_rfm_precompute","True") par.set_parval_from_str("reference_metric::rfm_precompute_Ccode_outdir",os.path.join(outdir,"rfm_files/")) # Evaluate BSSN + BSSN gauge RHSs with rfm_precompute enabled: import BSSN.BSSN_quantities as Bq par.set_parval_from_str("BSSN.BSSN_quantities::LeaveRicciSymbolic","True") rhs.BSSN_RHSs() if T4UU != None: import BSSN.BSSN_stress_energy_source_terms as Bsest Bsest.BSSN_source_terms_for_BSSN_RHSs(T4UU) rhs.trK_rhs += Bsest.sourceterm_trK_rhs for i in range(3): # Needed for Gamma-driving shift RHSs: rhs.Lambdabar_rhsU[i] += Bsest.sourceterm_Lambdabar_rhsU[i] # Needed for BSSN RHSs: rhs.lambda_rhsU[i] += Bsest.sourceterm_lambda_rhsU[i] for j in range(3): rhs.a_rhsDD[i][j] += Bsest.sourceterm_a_rhsDD[i][j] gaugerhs.BSSN_gauge_RHSs() # Add Kreiss-Oliger dissipation to the BSSN RHSs: thismodule = "KO_Dissipation" diss_strength = par.Cparameters("REAL", thismodule, "diss_strength", default_KO_strength) alpha_dKOD = ixp.declarerank1("alpha_dKOD") cf_dKOD = ixp.declarerank1("cf_dKOD") trK_dKOD = ixp.declarerank1("trK_dKOD") betU_dKOD = ixp.declarerank2("betU_dKOD","nosym") vetU_dKOD = ixp.declarerank2("vetU_dKOD","nosym") lambdaU_dKOD = ixp.declarerank2("lambdaU_dKOD","nosym") aDD_dKOD = ixp.declarerank3("aDD_dKOD","sym01") hDD_dKOD = ixp.declarerank3("hDD_dKOD","sym01") for k in range(3): gaugerhs.alpha_rhs += diss_strength*alpha_dKOD[k]*rfm.ReU[k] # ReU[k] = 1/scalefactor_orthog_funcform[k] rhs.cf_rhs += diss_strength* cf_dKOD[k]*rfm.ReU[k] # ReU[k] = 1/scalefactor_orthog_funcform[k] rhs.trK_rhs += diss_strength* trK_dKOD[k]*rfm.ReU[k] # ReU[k] = 1/scalefactor_orthog_funcform[k] for i in range(3): if "2ndOrder" in ShiftCondition: gaugerhs.bet_rhsU[i] += diss_strength* betU_dKOD[i][k]*rfm.ReU[k] # ReU[k] = 1/scalefactor_orthog_funcform[k] gaugerhs.vet_rhsU[i] += diss_strength* vetU_dKOD[i][k]*rfm.ReU[k] # ReU[k] = 1/scalefactor_orthog_funcform[k] rhs.lambda_rhsU[i] += diss_strength*lambdaU_dKOD[i][k]*rfm.ReU[k] # ReU[k] = 1/scalefactor_orthog_funcform[k] for j in range(3): rhs.a_rhsDD[i][j] += diss_strength*aDD_dKOD[i][j][k]*rfm.ReU[k] # ReU[k] = 1/scalefactor_orthog_funcform[k] rhs.h_rhsDD[i][j] += diss_strength*hDD_dKOD[i][j][k]*rfm.ReU[k] # ReU[k] = 1/scalefactor_orthog_funcform[k] # We use betaU as our upwinding control vector: Bq.BSSN_basic_tensors() betaU = Bq.betaU # Now that we are finished with all the rfm hatted # quantities in generic precomputed functional # form, let's restore them to their closed- # form expressions. par.set_parval_from_str("reference_metric::enable_rfm_precompute","False") # Reset to False to disable rfm_precompute. rfm.ref_metric__hatted_quantities() par.set_parval_from_str("BSSN.BSSN_quantities::LeaveRicciSymbolic","False") end = time.time() print("(BENCH) Finished BSSN RHS symbolic expressions in "+str(end-start)+" seconds.") # END: GENERATE SYMBOLIC EXPRESSIONS ###################################### BSSN_RHSs_SymbExpressions = [lhrh(lhs=gri.gfaccess("rhs_gfs","aDD00"), rhs=rhs.a_rhsDD[0][0]), lhrh(lhs=gri.gfaccess("rhs_gfs","aDD01"), rhs=rhs.a_rhsDD[0][1]), lhrh(lhs=gri.gfaccess("rhs_gfs","aDD02"), rhs=rhs.a_rhsDD[0][2]), lhrh(lhs=gri.gfaccess("rhs_gfs","aDD11"), rhs=rhs.a_rhsDD[1][1]), lhrh(lhs=gri.gfaccess("rhs_gfs","aDD12"), rhs=rhs.a_rhsDD[1][2]), lhrh(lhs=gri.gfaccess("rhs_gfs","aDD22"), rhs=rhs.a_rhsDD[2][2]), lhrh(lhs=gri.gfaccess("rhs_gfs","alpha"), rhs=gaugerhs.alpha_rhs), lhrh(lhs=gri.gfaccess("rhs_gfs","betU0"), rhs=gaugerhs.bet_rhsU[0]), lhrh(lhs=gri.gfaccess("rhs_gfs","betU1"), rhs=gaugerhs.bet_rhsU[1]), lhrh(lhs=gri.gfaccess("rhs_gfs","betU2"), rhs=gaugerhs.bet_rhsU[2]), lhrh(lhs=gri.gfaccess("rhs_gfs","cf"), rhs=rhs.cf_rhs), lhrh(lhs=gri.gfaccess("rhs_gfs","hDD00"), rhs=rhs.h_rhsDD[0][0]), lhrh(lhs=gri.gfaccess("rhs_gfs","hDD01") ,rhs=rhs.h_rhsDD[0][1]), lhrh(lhs=gri.gfaccess("rhs_gfs","hDD02"), rhs=rhs.h_rhsDD[0][2]), lhrh(lhs=gri.gfaccess("rhs_gfs","hDD11"), rhs=rhs.h_rhsDD[1][1]), lhrh(lhs=gri.gfaccess("rhs_gfs","hDD12"), rhs=rhs.h_rhsDD[1][2]), lhrh(lhs=gri.gfaccess("rhs_gfs","hDD22"), rhs=rhs.h_rhsDD[2][2]), lhrh(lhs=gri.gfaccess("rhs_gfs","lambdaU0"),rhs=rhs.lambda_rhsU[0]), lhrh(lhs=gri.gfaccess("rhs_gfs","lambdaU1"),rhs=rhs.lambda_rhsU[1]), lhrh(lhs=gri.gfaccess("rhs_gfs","lambdaU2"),rhs=rhs.lambda_rhsU[2]), lhrh(lhs=gri.gfaccess("rhs_gfs","trK"), rhs=rhs.trK_rhs), lhrh(lhs=gri.gfaccess("rhs_gfs","vetU0"), rhs=gaugerhs.vet_rhsU[0]), lhrh(lhs=gri.gfaccess("rhs_gfs","vetU1"), rhs=gaugerhs.vet_rhsU[1]), lhrh(lhs=gri.gfaccess("rhs_gfs","vetU2"), rhs=gaugerhs.vet_rhsU[2]) ] return [betaU,BSSN_RHSs_SymbExpressions]
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_NRPy_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] # Initialize all components of A and E in the *spherical basis* to zero ASphD = ixp.zerorank1() ESphD = ixp.zerorank1() ASphD[2] = (r * r * sp.sin(theta)**2) / 2 ESphD[2] = 2 * M * sp.sin(theta)**2 / sp.sqrt(1 + 2 * M / r) # <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(3): for j in range(3): AD[i] = drrefmetric__dx_0UDmatrix[(j, i)] * ASphD[j] ED[i] = drrefmetric__dx_0UDmatrix[(j, i)] * ESphD[j] #Step 4: Declare the basic spacetime quantities alpha = sp.symbols("alpha", real=True) betaU = ixp.declarerank1("betaU", DIM=3) gammaDD = ixp.declarerank2("gammaDD", "sym01", DIM=3) import GRHD.equations as GRHD GRHD.compute_sqrtgammaDET(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(3): for j in range(3): for k in range(3): LeviCivitaTensorUUU[i][j][ k] = LeviCivitaSymbolDDD[i][j][k] / GRHD.sqrtgammaDET # For the initial data, we can analytically take the derivatives of A_i ADdD = ixp.zerorank2() for i in range(3): for j in range(3): ADdD[i][j] = sp.simplify(sp.diff(AD[i], rfm.xxCart[j])) #global BU BU = ixp.zerorank1() for i in range(3): for j in range(3): for k in range(3): 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(3): for j in range(3): B2 += gammaDD[i][j] * BU[i] * BU[j] # Lower the index on B^i BD = ixp.zerorank1() for i in range(3): for j in range(3): BD[i] += gammaDD[i][j] * BU[j] # Step 4c: Calculate the Valencia 3-velocity global ValenciavU 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
def BSSN_constraints(add_T4UUmunu_source_terms=False): # Step 1.a: 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.b: 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 2: Hamiltonian constraint. # First declare all needed variables Bq.declare_BSSN_gridfunctions_if_not_declared_already() # Sets trK Bq.BSSN_basic_tensors() # Sets AbarDD Bq.gammabar__inverse_and_derivs() # Sets gammabarUU Bq.AbarUU_AbarUD_trAbar_AbarDD_dD() # Sets AbarUU and AbarDD_dD Bq.RicciBar__gammabarDD_dHatD__DGammaUDD__DGammaU() # Sets RbarDD Bq.phi_and_derivs() # Sets phi_dBarD & phi_dBarDD ############################### ############################### # HAMILTONIAN CONSTRAINT ############################### ############################### # Term 1: 2/3 K^2 global H H = sp.Rational(2, 3) * Bq.trK**2 # Term 2: -A_{ij} A^{ij} for i in range(DIM): for j in range(DIM): H += -Bq.AbarDD[i][j] * Bq.AbarUU[i][j] # Term 3a: trace(Rbar) Rbartrace = sp.sympify(0) for i in range(DIM): for j in range(DIM): Rbartrace += Bq.gammabarUU[i][j] * Bq.RbarDD[i][j] # Term 3b: -8 \bar{\gamma}^{ij} \bar{D}_i \phi \bar{D}_j \phi = -8*phi_dBar_times_phi_dBar # Term 3c: -8 \bar{\gamma}^{ij} \bar{D}_i \bar{D}_j \phi = -8*phi_dBarDD_contraction phi_dBar_times_phi_dBar = sp.sympify(0) # Term 3b phi_dBarDD_contraction = sp.sympify(0) # Term 3c for i in range(DIM): for j in range(DIM): phi_dBar_times_phi_dBar += Bq.gammabarUU[i][j] * Bq.phi_dBarD[ i] * Bq.phi_dBarD[j] phi_dBarDD_contraction += Bq.gammabarUU[i][j] * Bq.phi_dBarDD[i][j] # Add Term 3: H += Bq.exp_m4phi * (Rbartrace - 8 * (phi_dBar_times_phi_dBar + phi_dBarDD_contraction)) if add_T4UUmunu_source_terms: M_PI = par.Cparameters("#define", thismodule, "M_PI", "") # M_PI is pi as defined in C BTmunu.define_BSSN_T4UUmunu_rescaled_source_terms() rho = BTmunu.rho H += -16 * M_PI * rho # FIXME: ADD T4UUmunu SOURCE TERMS TO MOMENTUM CONSTRAINT! # Step 3: M^i, the momentum constraint ############################### ############################### # MOMENTUM CONSTRAINT ############################### ############################### # SEE Tutorial-BSSN_constraints.ipynb for full documentation. global MU MU = ixp.zerorank1() # Term 2: 6 A^{ij} \partial_j \phi: for i in range(DIM): for j in range(DIM): MU[i] += 6 * Bq.AbarUU[i][j] * Bq.phi_dD[j] # Term 3: -2/3 \bar{\gamma}^{ij} K_{,j} trK_dD = ixp.declarerank1( "trK_dD") # Not defined in BSSN_RHSs; only trK_dupD is defined there. for i in range(DIM): for j in range(DIM): MU[i] += -sp.Rational(2, 3) * Bq.gammabarUU[i][j] * trK_dD[j] # First define aDD_dD: aDD_dD = ixp.declarerank3("aDD_dD", "sym01") # Then evaluate the conformal covariant derivative \bar{D}_j \bar{A}_{lm} AbarDD_dBarD = ixp.zerorank3() for i in range(DIM): for j in range(DIM): for k in range(DIM): AbarDD_dBarD[i][j][k] = Bq.AbarDD_dD[i][j][k] for l in range(DIM): AbarDD_dBarD[i][j][ k] += -Bq.GammabarUDD[l][k][i] * Bq.AbarDD[l][j] AbarDD_dBarD[i][j][ k] += -Bq.GammabarUDD[l][k][j] * Bq.AbarDD[i][l] # Term 1: Contract twice with the metric to make \bar{D}_{j} \bar{A}^{ij} for i in range(DIM): for j in range(DIM): for k in range(DIM): for l in range(DIM): MU[i] += Bq.gammabarUU[i][k] * Bq.gammabarUU[j][ l] * AbarDD_dBarD[k][l][j] # Finally, we multiply by e^{-4 phi} and rescale the momentum constraint: for i in range(DIM): MU[i] *= Bq.exp_m4phi / rfm.ReU[i]
def VacuumMaxwellRHSs_rescaled(): global erhsU, arhsU, psi_rhs, Gamma_rhs, C, G, EU_Cart, AU_Cart #Step 0: Set the spatial dimension parameter to 3. par.set_parval_from_str("grid::DIM", 3) DIM = par.parval_from_str("grid::DIM") # Set reference metric related quantities rfm.reference_metric() # Register gridfunctions that are needed as input. # Declare the rank-1 indexed expressions E^{i}, A^{i}, # and \partial^{i} \psi, that are to be evolved in time. # Derivative variables like these must have an underscore # in them, so the finite difference module can parse # the variable name properly. # e^i eU = ixp.register_gridfunctions_for_single_rank1("EVOL", "eU") # \partial_k ( E^i ) --> rank two tensor eU_dD = ixp.declarerank2("eU_dD", "nosym") # a^i aU = ixp.register_gridfunctions_for_single_rank1("EVOL", "aU") # \partial_k ( a^i ) --> rank two tensor aU_dD = ixp.declarerank2("aU_dD", "nosym") # \partial_k partial_m ( a^i ) --> rank three tensor aU_dDD = ixp.declarerank3("aU_dDD", "sym12") # \psi is a scalar function that is time evolved # psi is unused here _psi = gri.register_gridfunctions("EVOL", ["psi"]) # \Gamma is a scalar function that is time evolved Gamma = gri.register_gridfunctions("EVOL", ["Gamma"]) # \partial_i \psi psi_dD = ixp.declarerank1("psi_dD") # \partial_i \Gamma Gamma_dD = ixp.declarerank1("Gamma_dD") # partial_i \partial_j \psi psi_dDD = ixp.declarerank2("psi_dDD", "sym01") ghatUU = rfm.ghatUU GammahatUDD = rfm.GammahatUDD GammahatUDDdD = rfm.GammahatUDDdD ReU = rfm.ReU ReUdD = rfm.ReUdD ReUdDD = rfm.ReUdDD # \partial_t a^i = -e^i - \frac{\hat{g}^{ij}\partial_j \varphi}{\text{ReU}[i]} arhsU = ixp.zerorank1() for i in range(DIM): arhsU[i] -= eU[i] for j in range(DIM): arhsU[i] -= (ghatUU[i][j] * psi_dD[j]) / ReU[i] # A^i AU = ixp.zerorank1() # \partial_k ( A^i ) --> rank two tensor AU_dD = ixp.zerorank2() # \partial_k partial_m ( A^i ) --> rank three tensor AU_dDD = ixp.zerorank3() for i in range(DIM): AU[i] = aU[i] * ReU[i] for j in range(DIM): AU_dD[i][j] = aU_dD[i][j] * ReU[i] + aU[i] * ReUdD[i][j] for k in range(DIM): AU_dDD[i][j][k] = aU_dDD[i][j][k]*ReU[i] + aU_dD[i][j]*ReUdD[i][k] +\ aU_dD[i][k]*ReUdD[i][j] + aU[i]*ReUdDD[i][j][k] # Term 1 = \hat{g}^{ij}\partial_j \Gamma Term1U = ixp.zerorank1() for i in range(DIM): for j in range(DIM): Term1U[i] += ghatUU[i][j] * Gamma_dD[j] # Term 2: A^i_{,kj} Term2UDD = ixp.zerorank3() for i in range(DIM): for j in range(DIM): for k in range(DIM): Term2UDD[i][j][k] += AU_dDD[i][k][j] # Term 3: \hat{\Gamma}^i_{mk,j} A^m + \hat{\Gamma}^i_{mk} A^m_{,j} # + \hat{\Gamma}^i_{dj}A^d_{,k} - \hat{\Gamma}^d_{kj} A^i_{,d} Term3UDD = ixp.zerorank3() for i in range(DIM): for j in range(DIM): for k in range(DIM): for m in range(DIM): Term3UDD[i][j][k] += GammahatUDDdD[i][m][k][j]*AU[m] \ + GammahatUDD[i][m][k]*AU_dD[m][j] \ + GammahatUDD[i][m][j]*AU_dD[m][k] \ - GammahatUDD[m][k][j]*AU_dD[i][m] # Term 4: \hat{\Gamma}^i_{dj}\hat{\Gamma}^d_{mk} A^m - # \hat{\Gamma}^d_{kj} \hat{\Gamma}^i_{md} A^m Term4UDD = ixp.zerorank3() for i in range(DIM): for j in range(DIM): for k in range(DIM): for m in range(DIM): for d in range(DIM): Term4UDD[i][j][k] += ( GammahatUDD[i][d][j]*GammahatUDD[d][m][k] \ -GammahatUDD[d][k][j]*GammahatUDD[i][m][d])*AU[m] # \partial_t E^i = \hat{g}^{ij}\partial_j \Gamma - \hat{\gamma}^{jk}* # (A^i_{,kj} # + \hat{\Gamma}^i_{mk,j} A^m + \hat{\Gamma}^i_{mk} A^m_{,j} # + \hat{\Gamma}^i_{dj} A^d_{,k} - \hat{\Gamma}^d_{kj} A^i_{,d} # + \hat{\Gamma}^i_{dj}\hat{\Gamma}^d_{mk} A^m # - \hat{\Gamma}^d_{kj} \hat{\Gamma}^i_{md} A^m) ErhsU = ixp.zerorank1() for i in range(DIM): ErhsU[i] += Term1U[i] for j in range(DIM): for k in range(DIM): ErhsU[i] -= ghatUU[j][k] * ( Term2UDD[i][j][k] + Term3UDD[i][j][k] + Term4UDD[i][j][k]) erhsU = ixp.zerorank1() for i in range(DIM): erhsU[i] = ErhsU[i] / ReU[i] # \partial_t \Gamma = -\hat{g}^{ij} (\partial_i \partial_j \varphi - # \hat{\Gamma}^k_{ji} \partial_k \varphi) Gamma_rhs = sp.sympify(0) for i in range(DIM): for j in range(DIM): Gamma_rhs -= ghatUU[i][j] * psi_dDD[i][j] for k in range(DIM): Gamma_rhs += ghatUU[i][j] * GammahatUDD[k][j][i] * psi_dD[k] # \partial_t \varphi = -\Gamma psi_rhs = -Gamma # \mathcal{G} \equiv \Gamma - \partial_i A^i + \hat{\Gamma}^i_{ji} A^j G = Gamma for i in range(DIM): G -= AU_dD[i][i] for j in range(DIM): G += GammahatUDD[i][j][i] * AU[j] # E^i EU = ixp.zerorank1() EU_dD = ixp.zerorank2() for i in range(DIM): EU[i] = eU[i] * ReU[i] for j in range(DIM): EU_dD[i][j] = eU_dD[i][j] * ReU[i] + eU[i] * ReUdD[i][j] C = sp.sympify(0) for i in range(DIM): C += EU_dD[i][i] for j in range(DIM): C += GammahatUDD[i][j][i] * EU[j] def Convert_to_Cartesian_basis(VU): # Coordinate transformation from original basis to Cartesian rfm.reference_metric() VU_Cart = ixp.zerorank1() Jac_dxCartU_dxOrigD = ixp.zerorank2() for i in range(DIM): for j in range(DIM): Jac_dxCartU_dxOrigD[i][j] = sp.diff(rfm.xxCart[i], rfm.xx[j]) for i in range(DIM): for j in range(DIM): VU_Cart[i] += Jac_dxCartU_dxOrigD[i][j] * VU[j] return VU_Cart AU_Cart = Convert_to_Cartesian_basis(AU) EU_Cart = Convert_to_Cartesian_basis(EU)