Convert to ADM variables on all grid points, including the boundary.

Omit the derivatives on the boundary, which only affect the time derivatives
of lapse and shift.

Regenerate the code.

2 files changed, 83 insertions, 27 deletions

diff --git a/ML_BSSN/schedule.ccl b/ML_BSSN/schedule.ccl
index 61ca090..c379899 100644
--- a/ML_BSSN/schedule.ccl
+++ b/ML_BSSN/schedule.ccl
@@ -245,14 +245,10 @@ schedule ML_BSSN_convertToADMBase IN ML_BSSN_convertToADMBaseGroup
   SYNC: ADMBase::shift
 } "ML_BSSN_convertToADMBase"
 
-
-if (CCTK_EQUALS(my_boundary_condition, "Minkowski"))
+schedule ML_BSSN_ADMBaseBoundary IN ML_BSSN_convertToADMBaseGroup AFTER ML_BSSN_convertToADMBase
 {
-  schedule ML_BSSN_ADMBaseBoundary IN ML_BSSN_convertToADMBaseGroup AFTER ML_BSSN_convertToADMBase
-  {
-    LANG: C
-  } "ML_BSSN_ADMBaseBoundary"
-}
+  LANG: C
+} "ML_BSSN_ADMBaseBoundary"
 
 schedule ML_BSSN_constraints IN ML_BSSN_constraintsCalcGroup
 {
diff --git a/ML_BSSN/src/ML_BSSN_ADMBaseBoundary.c b/ML_BSSN/src/ML_BSSN_ADMBaseBoundary.c
index df35b8c..7664795 100644
--- a/ML_BSSN/src/ML_BSSN_ADMBaseBoundary.c
+++ b/ML_BSSN/src/ML_BSSN_ADMBaseBoundary.c
@@ -110,9 +110,17 @@ void ML_BSSN_ADMBaseBoundary_Body(cGH const * const cctkGH, CCTK_INT const dir,
     subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
     
     /* Declare shorthands */
+    CCTK_REAL e4phi = INITVALUE;
+    CCTK_REAL g11 = INITVALUE, g12 = INITVALUE, g13 = INITVALUE, g22 = INITVALUE, g23 = INITVALUE, g33 = INITVALUE;
+    CCTK_REAL K11 = INITVALUE, K12 = INITVALUE, K13 = INITVALUE, K22 = INITVALUE, K23 = INITVALUE, K33 = INITVALUE;
     
     /* Declare local copies of grid functions */
+    CCTK_REAL AL = INITVALUE;
     CCTK_REAL alpL = INITVALUE;
+    CCTK_REAL alphaL = INITVALUE;
+    CCTK_REAL At11L = INITVALUE, At12L = INITVALUE, At13L = INITVALUE, At22L = INITVALUE, At23L = INITVALUE, At33L = INITVALUE;
+    CCTK_REAL B1L = INITVALUE, B2L = INITVALUE, B3L = INITVALUE;
+    CCTK_REAL beta1L = INITVALUE, beta2L = INITVALUE, beta3L = INITVALUE;
     CCTK_REAL betaxL = INITVALUE;
     CCTK_REAL betayL = INITVALUE;
     CCTK_REAL betazL = INITVALUE;
@@ -120,6 +128,7 @@ void ML_BSSN_ADMBaseBoundary_Body(cGH const * const cctkGH, CCTK_INT const dir,
     CCTK_REAL dtbetaxL = INITVALUE;
     CCTK_REAL dtbetayL = INITVALUE;
     CCTK_REAL dtbetazL = INITVALUE;
+    CCTK_REAL gt11L = INITVALUE, gt12L = INITVALUE, gt13L = INITVALUE, gt22L = INITVALUE, gt23L = INITVALUE, gt33L = INITVALUE;
     CCTK_REAL gxxL = INITVALUE;
     CCTK_REAL gxyL = INITVALUE;
     CCTK_REAL gxzL = INITVALUE;
@@ -132,11 +141,35 @@ void ML_BSSN_ADMBaseBoundary_Body(cGH const * const cctkGH, CCTK_INT const dir,
     CCTK_REAL kyyL = INITVALUE;
     CCTK_REAL kyzL = INITVALUE;
     CCTK_REAL kzzL = INITVALUE;
+    CCTK_REAL phiL = INITVALUE;
+    CCTK_REAL trKL = INITVALUE;
     /* Declare precomputed derivatives*/
     
     /* Declare derivatives */
     
     /* Assign local copies of grid functions */
+    AL = A[index];
+    alphaL = alpha[index];
+    At11L = At11[index];
+    At12L = At12[index];
+    At13L = At13[index];
+    At22L = At22[index];
+    At23L = At23[index];
+    At33L = At33[index];
+    B1L = B1[index];
+    B2L = B2[index];
+    B3L = B3[index];
+    beta1L = beta1[index];
+    beta2L = beta2[index];
+    beta3L = beta3[index];
+    gt11L = gt11[index];
+    gt12L = gt12[index];
+    gt13L = gt13[index];
+    gt22L = gt22[index];
+    gt23L = gt23[index];
+    gt33L = gt33[index];
+    phiL = phi[index];
+    trKL = trK[index];
     
     /* Assign local copies of subblock grid functions */
     
@@ -147,45 +180,72 @@ void ML_BSSN_ADMBaseBoundary_Body(cGH const * const cctkGH, CCTK_INT const dir,
     /* Precompute derivatives (old style) */
     
     /* Calculate temporaries and grid functions */
-    gxxL  =  1;
+    e4phi  =  exp(4*phiL);
     
-    gxyL  =  0;
+    g11  =  e4phi*gt11L;
     
-    gxzL  =  0;
+    g12  =  e4phi*gt12L;
     
-    gyyL  =  1;
+    g13  =  e4phi*gt13L;
     
-    gyzL  =  0;
+    g22  =  e4phi*gt22L;
     
-    gzzL  =  1;
+    g23  =  e4phi*gt23L;
     
-    kxxL  =  0;
+    g33  =  e4phi*gt33L;
     
-    kxyL  =  0;
+    gxxL  =  g11;
     
-    kxzL  =  0;
+    gxyL  =  g12;
     
-    kyyL  =  0;
+    gxzL  =  g13;
     
-    kyzL  =  0;
+    gyyL  =  g22;
     
-    kzzL  =  0;
+    gyzL  =  g23;
     
-    alpL  =  1;
+    gzzL  =  g33;
     
-    dtalpL  =  0;
+    K11  =  At11L*e4phi + g11*kthird*trKL;
     
-    betaxL  =  0;
+    K12  =  At12L*e4phi + g12*kthird*trKL;
     
-    betayL  =  0;
+    K13  =  At13L*e4phi + g13*kthird*trKL;
     
-    betazL  =  0;
+    K22  =  At22L*e4phi + g22*kthird*trKL;
     
-    dtbetaxL  =  0;
+    K23  =  At23L*e4phi + g23*kthird*trKL;
     
-    dtbetayL  =  0;
+    K33  =  At33L*e4phi + g33*kthird*trKL;
     
-    dtbetazL  =  0;
+    kxxL  =  K11;
+    
+    kxyL  =  K12;
+    
+    kxzL  =  K13;
+    
+    kyyL  =  K22;
+    
+    kyzL  =  K23;
+    
+    kzzL  =  K33;
+    
+    alpL  =  alphaL;
+    
+    betaxL  =  beta1L;
+    
+    betayL  =  beta2L;
+    
+    betazL  =  beta3L;
+    
+    dtalpL  =  harmonicF*(AL*(-1 + LapseAdvectionCoeff) - LapseAdvectionCoeff*trKL)*
+        pow(alphaL,harmonicN);
+    
+    dtbetaxL  =  B1L*ShiftGammaCoeff;
+    
+    dtbetayL  =  B2L*ShiftGammaCoeff;
+    
+    dtbetazL  =  B3L*ShiftGammaCoeff;
     
     
     /* Copy local copies back to grid functions */