Regenerate code (Kranc commit 3237af2566109f099ee78a7effb511a65dc18ae0)

2 files changed, 880 insertions, 880 deletions

diff --git a/ML_CCZ4/src/Boundaries.cc b/ML_CCZ4/src/Boundaries.cc
index 5cda75c..939d4c2 100644
--- a/ML_CCZ4/src/Boundaries.cc
+++ b/ML_CCZ4/src/Boundaries.cc
@@ -32,37 +32,26 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
   
   CCTK_INT ierr CCTK_ATTRIBUTE_UNUSED = 0;
   
-  if (CCTK_EQUALS(ML_curv_bound, "none"  ) ||
-      CCTK_EQUALS(ML_curv_bound, "static") ||
-      CCTK_EQUALS(ML_curv_bound, "flat"  ) ||
-      CCTK_EQUALS(ML_curv_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::ML_curv", ML_curv_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_curv_bound BC for ML_CCZ4::ML_curv!");
-  }
-  
-  if (CCTK_EQUALS(ML_dtlapse_bound, "none"  ) ||
-      CCTK_EQUALS(ML_dtlapse_bound, "static") ||
-      CCTK_EQUALS(ML_dtlapse_bound, "flat"  ) ||
-      CCTK_EQUALS(ML_dtlapse_bound, "zero"  ) )
+  if (CCTK_EQUALS(ML_log_confac_bound, "none"  ) ||
+      CCTK_EQUALS(ML_log_confac_bound, "static") ||
+      CCTK_EQUALS(ML_log_confac_bound, "flat"  ) ||
+      CCTK_EQUALS(ML_log_confac_bound, "zero"  ) )
   {
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::ML_dtlapse", ML_dtlapse_bound);
+                      "ML_CCZ4::ML_log_confac", ML_log_confac_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_dtlapse_bound BC for ML_CCZ4::ML_dtlapse!");
+       CCTK_WARN(0, "Failed to register ML_log_confac_bound BC for ML_CCZ4::ML_log_confac!");
   }
   
-  if (CCTK_EQUALS(ML_dtshift_bound, "none"  ) ||
-      CCTK_EQUALS(ML_dtshift_bound, "static") ||
-      CCTK_EQUALS(ML_dtshift_bound, "flat"  ) ||
-      CCTK_EQUALS(ML_dtshift_bound, "zero"  ) )
+  if (CCTK_EQUALS(ML_metric_bound, "none"  ) ||
+      CCTK_EQUALS(ML_metric_bound, "static") ||
+      CCTK_EQUALS(ML_metric_bound, "flat"  ) ||
+      CCTK_EQUALS(ML_metric_bound, "zero"  ) )
   {
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::ML_dtshift", ML_dtshift_bound);
+                      "ML_CCZ4::ML_metric", ML_metric_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_dtshift_bound BC for ML_CCZ4::ML_dtshift!");
+       CCTK_WARN(0, "Failed to register ML_metric_bound BC for ML_CCZ4::ML_metric!");
   }
   
   if (CCTK_EQUALS(ML_Gamma_bound, "none"  ) ||
@@ -76,6 +65,28 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register ML_Gamma_bound BC for ML_CCZ4::ML_Gamma!");
   }
   
+  if (CCTK_EQUALS(ML_trace_curv_bound, "none"  ) ||
+      CCTK_EQUALS(ML_trace_curv_bound, "static") ||
+      CCTK_EQUALS(ML_trace_curv_bound, "flat"  ) ||
+      CCTK_EQUALS(ML_trace_curv_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_CCZ4::ML_trace_curv", ML_trace_curv_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register ML_trace_curv_bound BC for ML_CCZ4::ML_trace_curv!");
+  }
+  
+  if (CCTK_EQUALS(ML_curv_bound, "none"  ) ||
+      CCTK_EQUALS(ML_curv_bound, "static") ||
+      CCTK_EQUALS(ML_curv_bound, "flat"  ) ||
+      CCTK_EQUALS(ML_curv_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_CCZ4::ML_curv", ML_curv_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register ML_curv_bound BC for ML_CCZ4::ML_curv!");
+  }
+  
   if (CCTK_EQUALS(ML_lapse_bound, "none"  ) ||
       CCTK_EQUALS(ML_lapse_bound, "static") ||
       CCTK_EQUALS(ML_lapse_bound, "flat"  ) ||
@@ -87,26 +98,15 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register ML_lapse_bound BC for ML_CCZ4::ML_lapse!");
   }
   
-  if (CCTK_EQUALS(ML_log_confac_bound, "none"  ) ||
-      CCTK_EQUALS(ML_log_confac_bound, "static") ||
-      CCTK_EQUALS(ML_log_confac_bound, "flat"  ) ||
-      CCTK_EQUALS(ML_log_confac_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::ML_log_confac", ML_log_confac_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_log_confac_bound BC for ML_CCZ4::ML_log_confac!");
-  }
-  
-  if (CCTK_EQUALS(ML_metric_bound, "none"  ) ||
-      CCTK_EQUALS(ML_metric_bound, "static") ||
-      CCTK_EQUALS(ML_metric_bound, "flat"  ) ||
-      CCTK_EQUALS(ML_metric_bound, "zero"  ) )
+  if (CCTK_EQUALS(ML_dtlapse_bound, "none"  ) ||
+      CCTK_EQUALS(ML_dtlapse_bound, "static") ||
+      CCTK_EQUALS(ML_dtlapse_bound, "flat"  ) ||
+      CCTK_EQUALS(ML_dtlapse_bound, "zero"  ) )
   {
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::ML_metric", ML_metric_bound);
+                      "ML_CCZ4::ML_dtlapse", ML_dtlapse_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_metric_bound BC for ML_CCZ4::ML_metric!");
+       CCTK_WARN(0, "Failed to register ML_dtlapse_bound BC for ML_CCZ4::ML_dtlapse!");
   }
   
   if (CCTK_EQUALS(ML_shift_bound, "none"  ) ||
@@ -120,6 +120,17 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register ML_shift_bound BC for ML_CCZ4::ML_shift!");
   }
   
+  if (CCTK_EQUALS(ML_dtshift_bound, "none"  ) ||
+      CCTK_EQUALS(ML_dtshift_bound, "static") ||
+      CCTK_EQUALS(ML_dtshift_bound, "flat"  ) ||
+      CCTK_EQUALS(ML_dtshift_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_CCZ4::ML_dtshift", ML_dtshift_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register ML_dtshift_bound BC for ML_CCZ4::ML_dtshift!");
+  }
+  
   if (CCTK_EQUALS(ML_Theta_bound, "none"  ) ||
       CCTK_EQUALS(ML_Theta_bound, "static") ||
       CCTK_EQUALS(ML_Theta_bound, "flat"  ) ||
@@ -131,125 +142,81 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register ML_Theta_bound BC for ML_CCZ4::ML_Theta!");
   }
   
-  if (CCTK_EQUALS(ML_trace_curv_bound, "none"  ) ||
-      CCTK_EQUALS(ML_trace_curv_bound, "static") ||
-      CCTK_EQUALS(ML_trace_curv_bound, "flat"  ) ||
-      CCTK_EQUALS(ML_trace_curv_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::ML_trace_curv", ML_trace_curv_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_trace_curv_bound BC for ML_CCZ4::ML_trace_curv!");
-  }
-  
-  if (CCTK_EQUALS(At11_bound, "none"  ) ||
-      CCTK_EQUALS(At11_bound, "static") ||
-      CCTK_EQUALS(At11_bound, "flat"  ) ||
-      CCTK_EQUALS(At11_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::At11", At11_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At11_bound BC for ML_CCZ4::At11!");
-  }
-  
-  if (CCTK_EQUALS(At12_bound, "none"  ) ||
-      CCTK_EQUALS(At12_bound, "static") ||
-      CCTK_EQUALS(At12_bound, "flat"  ) ||
-      CCTK_EQUALS(At12_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::At12", At12_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At12_bound BC for ML_CCZ4::At12!");
-  }
-  
-  if (CCTK_EQUALS(At13_bound, "none"  ) ||
-      CCTK_EQUALS(At13_bound, "static") ||
-      CCTK_EQUALS(At13_bound, "flat"  ) ||
-      CCTK_EQUALS(At13_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::At13", At13_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At13_bound BC for ML_CCZ4::At13!");
-  }
-  
-  if (CCTK_EQUALS(At22_bound, "none"  ) ||
-      CCTK_EQUALS(At22_bound, "static") ||
-      CCTK_EQUALS(At22_bound, "flat"  ) ||
-      CCTK_EQUALS(At22_bound, "zero"  ) )
+  if (CCTK_EQUALS(phi_bound, "none"  ) ||
+      CCTK_EQUALS(phi_bound, "static") ||
+      CCTK_EQUALS(phi_bound, "flat"  ) ||
+      CCTK_EQUALS(phi_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::At22", At22_bound);
+                      "ML_CCZ4::phi", phi_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At22_bound BC for ML_CCZ4::At22!");
+       CCTK_WARN(0, "Failed to register phi_bound BC for ML_CCZ4::phi!");
   }
   
-  if (CCTK_EQUALS(At23_bound, "none"  ) ||
-      CCTK_EQUALS(At23_bound, "static") ||
-      CCTK_EQUALS(At23_bound, "flat"  ) ||
-      CCTK_EQUALS(At23_bound, "zero"  ) )
+  if (CCTK_EQUALS(gt11_bound, "none"  ) ||
+      CCTK_EQUALS(gt11_bound, "static") ||
+      CCTK_EQUALS(gt11_bound, "flat"  ) ||
+      CCTK_EQUALS(gt11_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::At23", At23_bound);
+                      "ML_CCZ4::gt11", gt11_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At23_bound BC for ML_CCZ4::At23!");
+       CCTK_WARN(0, "Failed to register gt11_bound BC for ML_CCZ4::gt11!");
   }
   
-  if (CCTK_EQUALS(At33_bound, "none"  ) ||
-      CCTK_EQUALS(At33_bound, "static") ||
-      CCTK_EQUALS(At33_bound, "flat"  ) ||
-      CCTK_EQUALS(At33_bound, "zero"  ) )
+  if (CCTK_EQUALS(gt12_bound, "none"  ) ||
+      CCTK_EQUALS(gt12_bound, "static") ||
+      CCTK_EQUALS(gt12_bound, "flat"  ) ||
+      CCTK_EQUALS(gt12_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::At33", At33_bound);
+                      "ML_CCZ4::gt12", gt12_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At33_bound BC for ML_CCZ4::At33!");
+       CCTK_WARN(0, "Failed to register gt12_bound BC for ML_CCZ4::gt12!");
   }
   
-  if (CCTK_EQUALS(A_bound, "none"  ) ||
-      CCTK_EQUALS(A_bound, "static") ||
-      CCTK_EQUALS(A_bound, "flat"  ) ||
-      CCTK_EQUALS(A_bound, "zero"  ) )
+  if (CCTK_EQUALS(gt13_bound, "none"  ) ||
+      CCTK_EQUALS(gt13_bound, "static") ||
+      CCTK_EQUALS(gt13_bound, "flat"  ) ||
+      CCTK_EQUALS(gt13_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::A", A_bound);
+                      "ML_CCZ4::gt13", gt13_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register A_bound BC for ML_CCZ4::A!");
+       CCTK_WARN(0, "Failed to register gt13_bound BC for ML_CCZ4::gt13!");
   }
   
-  if (CCTK_EQUALS(B1_bound, "none"  ) ||
-      CCTK_EQUALS(B1_bound, "static") ||
-      CCTK_EQUALS(B1_bound, "flat"  ) ||
-      CCTK_EQUALS(B1_bound, "zero"  ) )
+  if (CCTK_EQUALS(gt22_bound, "none"  ) ||
+      CCTK_EQUALS(gt22_bound, "static") ||
+      CCTK_EQUALS(gt22_bound, "flat"  ) ||
+      CCTK_EQUALS(gt22_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::B1", B1_bound);
+                      "ML_CCZ4::gt22", gt22_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register B1_bound BC for ML_CCZ4::B1!");
+       CCTK_WARN(0, "Failed to register gt22_bound BC for ML_CCZ4::gt22!");
   }
   
-  if (CCTK_EQUALS(B2_bound, "none"  ) ||
-      CCTK_EQUALS(B2_bound, "static") ||
-      CCTK_EQUALS(B2_bound, "flat"  ) ||
-      CCTK_EQUALS(B2_bound, "zero"  ) )
+  if (CCTK_EQUALS(gt23_bound, "none"  ) ||
+      CCTK_EQUALS(gt23_bound, "static") ||
+      CCTK_EQUALS(gt23_bound, "flat"  ) ||
+      CCTK_EQUALS(gt23_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::B2", B2_bound);
+                      "ML_CCZ4::gt23", gt23_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register B2_bound BC for ML_CCZ4::B2!");
+       CCTK_WARN(0, "Failed to register gt23_bound BC for ML_CCZ4::gt23!");
   }
   
-  if (CCTK_EQUALS(B3_bound, "none"  ) ||
-      CCTK_EQUALS(B3_bound, "static") ||
-      CCTK_EQUALS(B3_bound, "flat"  ) ||
-      CCTK_EQUALS(B3_bound, "zero"  ) )
+  if (CCTK_EQUALS(gt33_bound, "none"  ) ||
+      CCTK_EQUALS(gt33_bound, "static") ||
+      CCTK_EQUALS(gt33_bound, "flat"  ) ||
+      CCTK_EQUALS(gt33_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::B3", B3_bound);
+                      "ML_CCZ4::gt33", gt33_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register B3_bound BC for ML_CCZ4::B3!");
+       CCTK_WARN(0, "Failed to register gt33_bound BC for ML_CCZ4::gt33!");
   }
   
   if (CCTK_EQUALS(Xt1_bound, "none"  ) ||
@@ -285,92 +252,103 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register Xt3_bound BC for ML_CCZ4::Xt3!");
   }
   
-  if (CCTK_EQUALS(alpha_bound, "none"  ) ||
-      CCTK_EQUALS(alpha_bound, "static") ||
-      CCTK_EQUALS(alpha_bound, "flat"  ) ||
-      CCTK_EQUALS(alpha_bound, "zero"  ) )
+  if (CCTK_EQUALS(trK_bound, "none"  ) ||
+      CCTK_EQUALS(trK_bound, "static") ||
+      CCTK_EQUALS(trK_bound, "flat"  ) ||
+      CCTK_EQUALS(trK_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::alpha", alpha_bound);
+                      "ML_CCZ4::trK", trK_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register alpha_bound BC for ML_CCZ4::alpha!");
+       CCTK_WARN(0, "Failed to register trK_bound BC for ML_CCZ4::trK!");
   }
   
-  if (CCTK_EQUALS(phi_bound, "none"  ) ||
-      CCTK_EQUALS(phi_bound, "static") ||
-      CCTK_EQUALS(phi_bound, "flat"  ) ||
-      CCTK_EQUALS(phi_bound, "zero"  ) )
+  if (CCTK_EQUALS(At11_bound, "none"  ) ||
+      CCTK_EQUALS(At11_bound, "static") ||
+      CCTK_EQUALS(At11_bound, "flat"  ) ||
+      CCTK_EQUALS(At11_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::phi", phi_bound);
+                      "ML_CCZ4::At11", At11_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register phi_bound BC for ML_CCZ4::phi!");
+       CCTK_WARN(0, "Failed to register At11_bound BC for ML_CCZ4::At11!");
   }
   
-  if (CCTK_EQUALS(gt11_bound, "none"  ) ||
-      CCTK_EQUALS(gt11_bound, "static") ||
-      CCTK_EQUALS(gt11_bound, "flat"  ) ||
-      CCTK_EQUALS(gt11_bound, "zero"  ) )
+  if (CCTK_EQUALS(At12_bound, "none"  ) ||
+      CCTK_EQUALS(At12_bound, "static") ||
+      CCTK_EQUALS(At12_bound, "flat"  ) ||
+      CCTK_EQUALS(At12_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::gt11", gt11_bound);
+                      "ML_CCZ4::At12", At12_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt11_bound BC for ML_CCZ4::gt11!");
+       CCTK_WARN(0, "Failed to register At12_bound BC for ML_CCZ4::At12!");
   }
   
-  if (CCTK_EQUALS(gt12_bound, "none"  ) ||
-      CCTK_EQUALS(gt12_bound, "static") ||
-      CCTK_EQUALS(gt12_bound, "flat"  ) ||
-      CCTK_EQUALS(gt12_bound, "zero"  ) )
+  if (CCTK_EQUALS(At13_bound, "none"  ) ||
+      CCTK_EQUALS(At13_bound, "static") ||
+      CCTK_EQUALS(At13_bound, "flat"  ) ||
+      CCTK_EQUALS(At13_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::gt12", gt12_bound);
+                      "ML_CCZ4::At13", At13_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt12_bound BC for ML_CCZ4::gt12!");
+       CCTK_WARN(0, "Failed to register At13_bound BC for ML_CCZ4::At13!");
   }
   
-  if (CCTK_EQUALS(gt13_bound, "none"  ) ||
-      CCTK_EQUALS(gt13_bound, "static") ||
-      CCTK_EQUALS(gt13_bound, "flat"  ) ||
-      CCTK_EQUALS(gt13_bound, "zero"  ) )
+  if (CCTK_EQUALS(At22_bound, "none"  ) ||
+      CCTK_EQUALS(At22_bound, "static") ||
+      CCTK_EQUALS(At22_bound, "flat"  ) ||
+      CCTK_EQUALS(At22_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::gt13", gt13_bound);
+                      "ML_CCZ4::At22", At22_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt13_bound BC for ML_CCZ4::gt13!");
+       CCTK_WARN(0, "Failed to register At22_bound BC for ML_CCZ4::At22!");
   }
   
-  if (CCTK_EQUALS(gt22_bound, "none"  ) ||
-      CCTK_EQUALS(gt22_bound, "static") ||
-      CCTK_EQUALS(gt22_bound, "flat"  ) ||
-      CCTK_EQUALS(gt22_bound, "zero"  ) )
+  if (CCTK_EQUALS(At23_bound, "none"  ) ||
+      CCTK_EQUALS(At23_bound, "static") ||
+      CCTK_EQUALS(At23_bound, "flat"  ) ||
+      CCTK_EQUALS(At23_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::gt22", gt22_bound);
+                      "ML_CCZ4::At23", At23_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt22_bound BC for ML_CCZ4::gt22!");
+       CCTK_WARN(0, "Failed to register At23_bound BC for ML_CCZ4::At23!");
   }
   
-  if (CCTK_EQUALS(gt23_bound, "none"  ) ||
-      CCTK_EQUALS(gt23_bound, "static") ||
-      CCTK_EQUALS(gt23_bound, "flat"  ) ||
-      CCTK_EQUALS(gt23_bound, "zero"  ) )
+  if (CCTK_EQUALS(At33_bound, "none"  ) ||
+      CCTK_EQUALS(At33_bound, "static") ||
+      CCTK_EQUALS(At33_bound, "flat"  ) ||
+      CCTK_EQUALS(At33_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::gt23", gt23_bound);
+                      "ML_CCZ4::At33", At33_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt23_bound BC for ML_CCZ4::gt23!");
+       CCTK_WARN(0, "Failed to register At33_bound BC for ML_CCZ4::At33!");
   }
   
-  if (CCTK_EQUALS(gt33_bound, "none"  ) ||
-      CCTK_EQUALS(gt33_bound, "static") ||
-      CCTK_EQUALS(gt33_bound, "flat"  ) ||
-      CCTK_EQUALS(gt33_bound, "zero"  ) )
+  if (CCTK_EQUALS(alpha_bound, "none"  ) ||
+      CCTK_EQUALS(alpha_bound, "static") ||
+      CCTK_EQUALS(alpha_bound, "flat"  ) ||
+      CCTK_EQUALS(alpha_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::gt33", gt33_bound);
+                      "ML_CCZ4::alpha", alpha_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt33_bound BC for ML_CCZ4::gt33!");
+       CCTK_WARN(0, "Failed to register alpha_bound BC for ML_CCZ4::alpha!");
+  }
+  
+  if (CCTK_EQUALS(A_bound, "none"  ) ||
+      CCTK_EQUALS(A_bound, "static") ||
+      CCTK_EQUALS(A_bound, "flat"  ) ||
+      CCTK_EQUALS(A_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_CCZ4::A", A_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register A_bound BC for ML_CCZ4::A!");
   }
   
   if (CCTK_EQUALS(beta1_bound, "none"  ) ||
@@ -406,82 +384,85 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register beta3_bound BC for ML_CCZ4::beta3!");
   }
   
-  if (CCTK_EQUALS(Theta_bound, "none"  ) ||
-      CCTK_EQUALS(Theta_bound, "static") ||
-      CCTK_EQUALS(Theta_bound, "flat"  ) ||
-      CCTK_EQUALS(Theta_bound, "zero"  ) )
+  if (CCTK_EQUALS(B1_bound, "none"  ) ||
+      CCTK_EQUALS(B1_bound, "static") ||
+      CCTK_EQUALS(B1_bound, "flat"  ) ||
+      CCTK_EQUALS(B1_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::Theta", Theta_bound);
+                      "ML_CCZ4::B1", B1_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Theta_bound BC for ML_CCZ4::Theta!");
+       CCTK_WARN(0, "Failed to register B1_bound BC for ML_CCZ4::B1!");
   }
   
-  if (CCTK_EQUALS(trK_bound, "none"  ) ||
-      CCTK_EQUALS(trK_bound, "static") ||
-      CCTK_EQUALS(trK_bound, "flat"  ) ||
-      CCTK_EQUALS(trK_bound, "zero"  ) )
+  if (CCTK_EQUALS(B2_bound, "none"  ) ||
+      CCTK_EQUALS(B2_bound, "static") ||
+      CCTK_EQUALS(B2_bound, "flat"  ) ||
+      CCTK_EQUALS(B2_bound, "zero"  ) )
   {
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_CCZ4::trK", trK_bound);
+                      "ML_CCZ4::B2", B2_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register trK_bound BC for ML_CCZ4::trK!");
+       CCTK_WARN(0, "Failed to register B2_bound BC for ML_CCZ4::B2!");
   }
   
-  if (CCTK_EQUALS(ML_curv_bound, "radiative"))
+  if (CCTK_EQUALS(B3_bound, "none"  ) ||
+      CCTK_EQUALS(B3_bound, "static") ||
+      CCTK_EQUALS(B3_bound, "flat"  ) ||
+      CCTK_EQUALS(B3_bound, "zero"  ) )
   {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_ML_curv_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_curv_bound < 0) handle_ML_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_curv_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_curv_bound , ML_curv_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ML_curv_bound ,ML_curv_bound_speed, "SPEED") < 0)
-       CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_curv_bound, 
-                      "ML_CCZ4::ML_curv", "Radiation");
-  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_CCZ4::B3", B3_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_curv!");
+       CCTK_WARN(0, "Failed to register B3_bound BC for ML_CCZ4::B3!");
+  }
   
+  if (CCTK_EQUALS(Theta_bound, "none"  ) ||
+      CCTK_EQUALS(Theta_bound, "static") ||
+      CCTK_EQUALS(Theta_bound, "flat"  ) ||
+      CCTK_EQUALS(Theta_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_CCZ4::Theta", Theta_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Theta_bound BC for ML_CCZ4::Theta!");
   }
   
-  if (CCTK_EQUALS(ML_dtlapse_bound, "radiative"))
+  if (CCTK_EQUALS(ML_log_confac_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_ML_dtlapse_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_dtlapse_bound < 0) handle_ML_dtlapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_dtlapse_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_dtlapse_bound , ML_dtlapse_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_ML_log_confac_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_log_confac_bound < 0) handle_ML_log_confac_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_log_confac_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_log_confac_bound , ML_log_confac_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ML_dtlapse_bound ,ML_dtlapse_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_log_confac_bound ,ML_log_confac_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtlapse_bound, 
-                      "ML_CCZ4::ML_dtlapse", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_log_confac_bound, 
+                      "ML_CCZ4::ML_log_confac", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_dtlapse!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_log_confac!");
   
   }
   
-  if (CCTK_EQUALS(ML_dtshift_bound, "radiative"))
+  if (CCTK_EQUALS(ML_metric_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_ML_dtshift_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_dtshift_bound < 0) handle_ML_dtshift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_dtshift_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_dtshift_bound , ML_dtshift_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_ML_metric_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_metric_bound < 0) handle_ML_metric_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_metric_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_metric_bound , ML_metric_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ML_dtshift_bound ,ML_dtshift_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_metric_bound ,ML_metric_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtshift_bound, 
-                      "ML_CCZ4::ML_dtshift", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_metric_bound, 
+                      "ML_CCZ4::ML_metric", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_dtshift!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_metric!");
   
   }
   
@@ -504,307 +485,269 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(ML_lapse_bound, "radiative"))
+  if (CCTK_EQUALS(ML_trace_curv_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_ML_lapse_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_lapse_bound < 0) handle_ML_lapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_lapse_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_lapse_bound , ML_lapse_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_ML_trace_curv_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_trace_curv_bound < 0) handle_ML_trace_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_trace_curv_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_trace_curv_bound , ML_trace_curv_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ML_lapse_bound ,ML_lapse_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_trace_curv_bound ,ML_trace_curv_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_lapse_bound, 
-                      "ML_CCZ4::ML_lapse", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_trace_curv_bound, 
+                      "ML_CCZ4::ML_trace_curv", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_lapse!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_trace_curv!");
   
   }
   
-  if (CCTK_EQUALS(ML_log_confac_bound, "radiative"))
+  if (CCTK_EQUALS(ML_curv_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_ML_log_confac_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_log_confac_bound < 0) handle_ML_log_confac_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_log_confac_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_log_confac_bound , ML_log_confac_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_ML_curv_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_curv_bound < 0) handle_ML_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_curv_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_curv_bound , ML_curv_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ML_log_confac_bound ,ML_log_confac_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_curv_bound ,ML_curv_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_log_confac_bound, 
-                      "ML_CCZ4::ML_log_confac", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_curv_bound, 
+                      "ML_CCZ4::ML_curv", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_log_confac!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_curv!");
   
   }
   
-  if (CCTK_EQUALS(ML_metric_bound, "radiative"))
+  if (CCTK_EQUALS(ML_lapse_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_ML_metric_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_metric_bound < 0) handle_ML_metric_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_metric_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_metric_bound , ML_metric_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_ML_lapse_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_lapse_bound < 0) handle_ML_lapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_lapse_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_lapse_bound , ML_lapse_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ML_metric_bound ,ML_metric_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_lapse_bound ,ML_lapse_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_metric_bound, 
-                      "ML_CCZ4::ML_metric", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_lapse_bound, 
+                      "ML_CCZ4::ML_lapse", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_metric!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_lapse!");
   
   }
   
-  if (CCTK_EQUALS(ML_shift_bound, "radiative"))
+  if (CCTK_EQUALS(ML_dtlapse_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_ML_shift_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_shift_bound < 0) handle_ML_shift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_shift_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_shift_bound , ML_shift_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_ML_dtlapse_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_dtlapse_bound < 0) handle_ML_dtlapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_dtlapse_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_dtlapse_bound , ML_dtlapse_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ML_shift_bound ,ML_shift_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_dtlapse_bound ,ML_dtlapse_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_shift_bound, 
-                      "ML_CCZ4::ML_shift", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtlapse_bound, 
+                      "ML_CCZ4::ML_dtlapse", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_shift!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_dtlapse!");
   
   }
   
-  if (CCTK_EQUALS(ML_Theta_bound, "radiative"))
+  if (CCTK_EQUALS(ML_shift_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_ML_Theta_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_Theta_bound < 0) handle_ML_Theta_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_Theta_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_Theta_bound , ML_Theta_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_ML_shift_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_shift_bound < 0) handle_ML_shift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_shift_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_shift_bound , ML_shift_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ML_Theta_bound ,ML_Theta_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_shift_bound ,ML_shift_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_Theta_bound, 
-                      "ML_CCZ4::ML_Theta", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_shift_bound, 
+                      "ML_CCZ4::ML_shift", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_Theta!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_shift!");
   
   }
   
-  if (CCTK_EQUALS(ML_trace_curv_bound, "radiative"))
+  if (CCTK_EQUALS(ML_dtshift_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_ML_trace_curv_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_trace_curv_bound < 0) handle_ML_trace_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_trace_curv_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_trace_curv_bound , ML_trace_curv_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_ML_dtshift_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_dtshift_bound < 0) handle_ML_dtshift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_dtshift_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_dtshift_bound , ML_dtshift_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ML_trace_curv_bound ,ML_trace_curv_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_dtshift_bound ,ML_dtshift_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_trace_curv_bound, 
-                      "ML_CCZ4::ML_trace_curv", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_trace_curv!");
-  
-  }
-  
-  if (CCTK_EQUALS(At11_bound, "radiative"))
-  {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_At11_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At11_bound < 0) handle_At11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At11_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At11_bound , At11_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_At11_bound ,At11_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At11_bound, 
-                      "ML_CCZ4::At11", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At11!");
-  
-  }
-  
-  if (CCTK_EQUALS(At12_bound, "radiative"))
-  {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_At12_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At12_bound < 0) handle_At12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At12_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At12_bound , At12_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_At12_bound ,At12_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At12_bound, 
-                      "ML_CCZ4::At12", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtshift_bound, 
+                      "ML_CCZ4::ML_dtshift", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At12!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_dtshift!");
   
   }
   
-  if (CCTK_EQUALS(At13_bound, "radiative"))
+  if (CCTK_EQUALS(ML_Theta_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_At13_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At13_bound < 0) handle_At13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At13_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At13_bound , At13_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_ML_Theta_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_Theta_bound < 0) handle_ML_Theta_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_Theta_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_Theta_bound , ML_Theta_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_At13_bound ,At13_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
+    if (Util_TableSetReal(handle_ML_Theta_bound ,ML_Theta_bound_speed, "SPEED") < 0)
+       CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At13_bound, 
-                      "ML_CCZ4::At13", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_Theta_bound, 
+                      "ML_CCZ4::ML_Theta", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At13!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::ML_Theta!");
   
   }
   
-  if (CCTK_EQUALS(At22_bound, "radiative"))
+  if (CCTK_EQUALS(phi_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_At22_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At22_bound < 0) handle_At22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At22_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At22_bound , At22_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_phi_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_phi_bound < 0) handle_phi_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_phi_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_phi_bound , phi_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_At22_bound ,At22_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_phi_bound ,phi_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At22_bound, 
-                      "ML_CCZ4::At22", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_phi_bound, 
+                      "ML_CCZ4::phi", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At22!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::phi!");
   
   }
   
-  if (CCTK_EQUALS(At23_bound, "radiative"))
+  if (CCTK_EQUALS(gt11_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_At23_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At23_bound < 0) handle_At23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At23_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At23_bound , At23_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_gt11_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt11_bound < 0) handle_gt11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt11_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt11_bound , gt11_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_At23_bound ,At23_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_gt11_bound ,gt11_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At23_bound, 
-                      "ML_CCZ4::At23", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt11_bound, 
+                      "ML_CCZ4::gt11", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At23!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt11!");
   
   }
   
-  if (CCTK_EQUALS(At33_bound, "radiative"))
+  if (CCTK_EQUALS(gt12_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_At33_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At33_bound < 0) handle_At33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At33_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At33_bound , At33_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_gt12_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt12_bound < 0) handle_gt12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt12_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt12_bound , gt12_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_At33_bound ,At33_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_gt12_bound ,gt12_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At33_bound, 
-                      "ML_CCZ4::At33", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt12_bound, 
+                      "ML_CCZ4::gt12", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At33!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt12!");
   
   }
   
-  if (CCTK_EQUALS(A_bound, "radiative"))
+  if (CCTK_EQUALS(gt13_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_A_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_A_bound < 0) handle_A_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_A_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_A_bound , A_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_gt13_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt13_bound < 0) handle_gt13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt13_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt13_bound , gt13_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_A_bound ,A_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_gt13_bound ,gt13_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_A_bound, 
-                      "ML_CCZ4::A", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt13_bound, 
+                      "ML_CCZ4::gt13", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::A!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt13!");
   
   }
   
-  if (CCTK_EQUALS(B1_bound, "radiative"))
+  if (CCTK_EQUALS(gt22_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_B1_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_B1_bound < 0) handle_B1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B1_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_B1_bound , B1_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_gt22_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt22_bound < 0) handle_gt22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt22_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt22_bound , gt22_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_B1_bound ,B1_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_gt22_bound ,gt22_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B1_bound, 
-                      "ML_CCZ4::B1", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt22_bound, 
+                      "ML_CCZ4::gt22", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::B1!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt22!");
   
   }
   
-  if (CCTK_EQUALS(B2_bound, "radiative"))
+  if (CCTK_EQUALS(gt23_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_B2_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_B2_bound < 0) handle_B2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B2_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_B2_bound , B2_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_gt23_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt23_bound < 0) handle_gt23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt23_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt23_bound , gt23_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_B2_bound ,B2_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_gt23_bound ,gt23_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B2_bound, 
-                      "ML_CCZ4::B2", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt23_bound, 
+                      "ML_CCZ4::gt23", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::B2!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt23!");
   
   }
   
-  if (CCTK_EQUALS(B3_bound, "radiative"))
+  if (CCTK_EQUALS(gt33_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_B3_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_B3_bound < 0) handle_B3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B3_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_B3_bound , B3_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_gt33_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt33_bound < 0) handle_gt33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt33_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt33_bound , gt33_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_B3_bound ,B3_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_gt33_bound ,gt33_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B3_bound, 
-                      "ML_CCZ4::B3", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt33_bound, 
+                      "ML_CCZ4::gt33", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::B3!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt33!");
   
   }
   
@@ -865,155 +808,174 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(alpha_bound, "radiative"))
+  if (CCTK_EQUALS(trK_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_alpha_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_alpha_bound < 0) handle_alpha_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_alpha_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_alpha_bound , alpha_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_trK_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_trK_bound < 0) handle_trK_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_trK_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_trK_bound , trK_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_alpha_bound ,alpha_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_trK_bound ,trK_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_alpha_bound, 
-                      "ML_CCZ4::alpha", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_trK_bound, 
+                      "ML_CCZ4::trK", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::alpha!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::trK!");
   
   }
   
-  if (CCTK_EQUALS(phi_bound, "radiative"))
+  if (CCTK_EQUALS(At11_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_phi_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_phi_bound < 0) handle_phi_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_phi_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_phi_bound , phi_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_At11_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At11_bound < 0) handle_At11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At11_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At11_bound , At11_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_phi_bound ,phi_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_At11_bound ,At11_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_phi_bound, 
-                      "ML_CCZ4::phi", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At11_bound, 
+                      "ML_CCZ4::At11", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::phi!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At11!");
   
   }
   
-  if (CCTK_EQUALS(gt11_bound, "radiative"))
+  if (CCTK_EQUALS(At12_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_gt11_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt11_bound < 0) handle_gt11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt11_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt11_bound , gt11_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_At12_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At12_bound < 0) handle_At12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At12_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At12_bound , At12_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_gt11_bound ,gt11_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_At12_bound ,At12_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt11_bound, 
-                      "ML_CCZ4::gt11", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At12_bound, 
+                      "ML_CCZ4::At12", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt11!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At12!");
   
   }
   
-  if (CCTK_EQUALS(gt12_bound, "radiative"))
+  if (CCTK_EQUALS(At13_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_gt12_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt12_bound < 0) handle_gt12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt12_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt12_bound , gt12_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_At13_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At13_bound < 0) handle_At13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At13_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At13_bound , At13_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_gt12_bound ,gt12_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_At13_bound ,At13_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt12_bound, 
-                      "ML_CCZ4::gt12", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At13_bound, 
+                      "ML_CCZ4::At13", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt12!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At13!");
   
   }
   
-  if (CCTK_EQUALS(gt13_bound, "radiative"))
+  if (CCTK_EQUALS(At22_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_gt13_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt13_bound < 0) handle_gt13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt13_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt13_bound , gt13_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_At22_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At22_bound < 0) handle_At22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At22_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At22_bound , At22_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_gt13_bound ,gt13_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_At22_bound ,At22_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt13_bound, 
-                      "ML_CCZ4::gt13", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At22_bound, 
+                      "ML_CCZ4::At22", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt13!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At22!");
   
   }
   
-  if (CCTK_EQUALS(gt22_bound, "radiative"))
+  if (CCTK_EQUALS(At23_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_gt22_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt22_bound < 0) handle_gt22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt22_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt22_bound , gt22_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_At23_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At23_bound < 0) handle_At23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At23_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At23_bound , At23_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_gt22_bound ,gt22_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_At23_bound ,At23_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt22_bound, 
-                      "ML_CCZ4::gt22", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At23_bound, 
+                      "ML_CCZ4::At23", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt22!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At23!");
   
   }
   
-  if (CCTK_EQUALS(gt23_bound, "radiative"))
+  if (CCTK_EQUALS(At33_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_gt23_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt23_bound < 0) handle_gt23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt23_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt23_bound , gt23_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_At33_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At33_bound < 0) handle_At33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At33_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At33_bound , At33_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_gt23_bound ,gt23_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_At33_bound ,At33_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt23_bound, 
-                      "ML_CCZ4::gt23", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At33_bound, 
+                      "ML_CCZ4::At33", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt23!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::At33!");
   
   }
   
-  if (CCTK_EQUALS(gt33_bound, "radiative"))
+  if (CCTK_EQUALS(alpha_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_gt33_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt33_bound < 0) handle_gt33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt33_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt33_bound , gt33_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_alpha_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_alpha_bound < 0) handle_alpha_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_alpha_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_alpha_bound , alpha_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_gt33_bound ,gt33_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_alpha_bound ,alpha_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt33_bound, 
-                      "ML_CCZ4::gt33", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_alpha_bound, 
+                      "ML_CCZ4::alpha", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::gt33!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::alpha!");
+  
+  }
+  
+  if (CCTK_EQUALS(A_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_A_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_A_bound < 0) handle_A_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_A_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_A_bound , A_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_A_bound ,A_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_A_bound, 
+                      "ML_CCZ4::A", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::A!");
   
   }
   
@@ -1074,92 +1036,113 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(Theta_bound, "radiative"))
+  if (CCTK_EQUALS(B1_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_Theta_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_Theta_bound < 0) handle_Theta_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_Theta_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_Theta_bound , Theta_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_B1_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_B1_bound < 0) handle_B1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_B1_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_B1_bound , B1_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_Theta_bound ,Theta_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_B1_bound ,B1_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_Theta_bound, 
-                      "ML_CCZ4::Theta", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B1_bound, 
+                      "ML_CCZ4::B1", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::Theta!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::B1!");
   
   }
   
-  if (CCTK_EQUALS(trK_bound, "radiative"))
+  if (CCTK_EQUALS(B2_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_trK_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_trK_bound < 0) handle_trK_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_trK_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_trK_bound , trK_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_B2_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_B2_bound < 0) handle_B2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_B2_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_B2_bound , B2_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_trK_bound ,trK_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_B2_bound ,B2_bound_speed, "SPEED") < 0)
         CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_trK_bound, 
-                      "ML_CCZ4::trK", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B2_bound, 
+                      "ML_CCZ4::B2", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::trK!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::B2!");
   
   }
   
-  if (CCTK_EQUALS(ML_curv_bound, "scalar"))
+  if (CCTK_EQUALS(B3_bound, "radiative"))
   {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_ML_curv_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_curv_bound < 0) handle_ML_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_curv_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_curv_bound ,ML_curv_bound_scalar, "SCALAR") < 0)
-        CCTK_WARN(0, "could not set SCALAR value in table!");
+   /* select radiation boundary condition */
+    static CCTK_INT handle_B3_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_B3_bound < 0) handle_B3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_B3_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_B3_bound , B3_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_B3_bound ,B3_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_curv_bound, 
-                      "ML_CCZ4::ML_curv", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B3_bound, 
+                      "ML_CCZ4::B3", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_curv!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::B3!");
   
   }
   
-  if (CCTK_EQUALS(ML_dtlapse_bound, "scalar"))
+  if (CCTK_EQUALS(Theta_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_Theta_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_Theta_bound < 0) handle_Theta_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_Theta_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_Theta_bound , Theta_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_Theta_bound ,Theta_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_Theta_bound, 
+                      "ML_CCZ4::Theta", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_CCZ4::Theta!");
+  
+  }
+  
+  if (CCTK_EQUALS(ML_log_confac_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_ML_dtlapse_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_dtlapse_bound < 0) handle_ML_dtlapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_dtlapse_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_dtlapse_bound ,ML_dtlapse_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_ML_log_confac_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_log_confac_bound < 0) handle_ML_log_confac_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_log_confac_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_log_confac_bound ,ML_log_confac_bound_scalar, "SCALAR") < 0)
         CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtlapse_bound, 
-                      "ML_CCZ4::ML_dtlapse", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_log_confac_bound, 
+                      "ML_CCZ4::ML_log_confac", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_dtlapse!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_log_confac!");
   
   }
   
-  if (CCTK_EQUALS(ML_dtshift_bound, "scalar"))
+  if (CCTK_EQUALS(ML_metric_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_ML_dtshift_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_dtshift_bound < 0) handle_ML_dtshift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_dtshift_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_dtshift_bound ,ML_dtshift_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_ML_metric_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_metric_bound < 0) handle_ML_metric_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_metric_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_metric_bound ,ML_metric_bound_scalar, "SCALAR") < 0)
         CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtshift_bound, 
-                      "ML_CCZ4::ML_dtshift", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_metric_bound, 
+                      "ML_CCZ4::ML_metric", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_dtshift!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_metric!");
   
   }
   
@@ -1180,275 +1163,241 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(ML_lapse_bound, "scalar"))
+  if (CCTK_EQUALS(ML_trace_curv_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_ML_lapse_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_lapse_bound < 0) handle_ML_lapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_lapse_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_lapse_bound ,ML_lapse_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_ML_trace_curv_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_trace_curv_bound < 0) handle_ML_trace_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_trace_curv_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_trace_curv_bound ,ML_trace_curv_bound_scalar, "SCALAR") < 0)
         CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_lapse_bound, 
-                      "ML_CCZ4::ML_lapse", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_trace_curv_bound, 
+                      "ML_CCZ4::ML_trace_curv", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_lapse!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_trace_curv!");
   
   }
   
-  if (CCTK_EQUALS(ML_log_confac_bound, "scalar"))
+  if (CCTK_EQUALS(ML_curv_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_ML_log_confac_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_log_confac_bound < 0) handle_ML_log_confac_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_log_confac_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_log_confac_bound ,ML_log_confac_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_ML_curv_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_curv_bound < 0) handle_ML_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_curv_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_curv_bound ,ML_curv_bound_scalar, "SCALAR") < 0)
         CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_log_confac_bound, 
-                      "ML_CCZ4::ML_log_confac", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_curv_bound, 
+                      "ML_CCZ4::ML_curv", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_log_confac!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_curv!");
   
   }
   
-  if (CCTK_EQUALS(ML_metric_bound, "scalar"))
+  if (CCTK_EQUALS(ML_lapse_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_ML_metric_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_metric_bound < 0) handle_ML_metric_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_metric_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_metric_bound ,ML_metric_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_ML_lapse_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_lapse_bound < 0) handle_ML_lapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_lapse_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_lapse_bound ,ML_lapse_bound_scalar, "SCALAR") < 0)
         CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_metric_bound, 
-                      "ML_CCZ4::ML_metric", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_lapse_bound, 
+                      "ML_CCZ4::ML_lapse", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_metric!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_lapse!");
   
   }
   
-  if (CCTK_EQUALS(ML_shift_bound, "scalar"))
+  if (CCTK_EQUALS(ML_dtlapse_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_ML_shift_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_shift_bound < 0) handle_ML_shift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_shift_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_shift_bound ,ML_shift_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_ML_dtlapse_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_dtlapse_bound < 0) handle_ML_dtlapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_dtlapse_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_dtlapse_bound ,ML_dtlapse_bound_scalar, "SCALAR") < 0)
         CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_shift_bound, 
-                      "ML_CCZ4::ML_shift", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtlapse_bound, 
+                      "ML_CCZ4::ML_dtlapse", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_shift!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_dtlapse!");
   
   }
   
-  if (CCTK_EQUALS(ML_Theta_bound, "scalar"))
+  if (CCTK_EQUALS(ML_shift_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_ML_Theta_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_Theta_bound < 0) handle_ML_Theta_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_Theta_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_Theta_bound ,ML_Theta_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_ML_shift_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_shift_bound < 0) handle_ML_shift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_shift_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_shift_bound ,ML_shift_bound_scalar, "SCALAR") < 0)
         CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_Theta_bound, 
-                      "ML_CCZ4::ML_Theta", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_shift_bound, 
+                      "ML_CCZ4::ML_shift", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_Theta!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_shift!");
   
   }
   
-  if (CCTK_EQUALS(ML_trace_curv_bound, "scalar"))
+  if (CCTK_EQUALS(ML_dtshift_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_ML_trace_curv_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_trace_curv_bound < 0) handle_ML_trace_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_trace_curv_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_trace_curv_bound ,ML_trace_curv_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_ML_dtshift_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_dtshift_bound < 0) handle_ML_dtshift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_dtshift_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_dtshift_bound ,ML_dtshift_bound_scalar, "SCALAR") < 0)
         CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_trace_curv_bound, 
-                      "ML_CCZ4::ML_trace_curv", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_trace_curv!");
-  
-  }
-  
-  if (CCTK_EQUALS(At11_bound, "scalar"))
-  {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_At11_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At11_bound < 0) handle_At11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At11_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At11_bound ,At11_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At11_bound, 
-                      "ML_CCZ4::At11", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At11!");
-  
-  }
-  
-  if (CCTK_EQUALS(At12_bound, "scalar"))
-  {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_At12_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At12_bound < 0) handle_At12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At12_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At12_bound ,At12_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At12_bound, 
-                      "ML_CCZ4::At12", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtshift_bound, 
+                      "ML_CCZ4::ML_dtshift", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At12!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_dtshift!");
   
   }
   
-  if (CCTK_EQUALS(At13_bound, "scalar"))
+  if (CCTK_EQUALS(ML_Theta_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_At13_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At13_bound < 0) handle_At13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At13_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At13_bound ,At13_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
+    static CCTK_INT handle_ML_Theta_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_Theta_bound < 0) handle_ML_Theta_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_Theta_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_Theta_bound ,ML_Theta_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At13_bound, 
-                      "ML_CCZ4::At13", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_Theta_bound, 
+                      "ML_CCZ4::ML_Theta", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At13!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_CCZ4::ML_Theta!");
   
   }
   
-  if (CCTK_EQUALS(At22_bound, "scalar"))
+  if (CCTK_EQUALS(phi_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_At22_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At22_bound < 0) handle_At22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At22_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At22_bound ,At22_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_phi_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_phi_bound < 0) handle_phi_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_phi_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_phi_bound ,phi_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At22_bound, 
-                      "ML_CCZ4::At22", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_phi_bound, 
+                      "ML_CCZ4::phi", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At22!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::phi!");
   
   }
   
-  if (CCTK_EQUALS(At23_bound, "scalar"))
+  if (CCTK_EQUALS(gt11_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_At23_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At23_bound < 0) handle_At23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At23_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At23_bound ,At23_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_gt11_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt11_bound < 0) handle_gt11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt11_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt11_bound ,gt11_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At23_bound, 
-                      "ML_CCZ4::At23", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt11_bound, 
+                      "ML_CCZ4::gt11", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At23!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt11!");
   
   }
   
-  if (CCTK_EQUALS(At33_bound, "scalar"))
+  if (CCTK_EQUALS(gt12_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_At33_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_At33_bound < 0) handle_At33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At33_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_At33_bound ,At33_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_gt12_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt12_bound < 0) handle_gt12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt12_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt12_bound ,gt12_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At33_bound, 
-                      "ML_CCZ4::At33", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt12_bound, 
+                      "ML_CCZ4::gt12", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At33!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt12!");
   
   }
   
-  if (CCTK_EQUALS(A_bound, "scalar"))
+  if (CCTK_EQUALS(gt13_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_A_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_A_bound < 0) handle_A_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_A_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_A_bound ,A_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_gt13_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt13_bound < 0) handle_gt13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt13_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt13_bound ,gt13_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_A_bound, 
-                      "ML_CCZ4::A", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt13_bound, 
+                      "ML_CCZ4::gt13", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::A!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt13!");
   
   }
   
-  if (CCTK_EQUALS(B1_bound, "scalar"))
+  if (CCTK_EQUALS(gt22_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_B1_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_B1_bound < 0) handle_B1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B1_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_B1_bound ,B1_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_gt22_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt22_bound < 0) handle_gt22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt22_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt22_bound ,gt22_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B1_bound, 
-                      "ML_CCZ4::B1", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt22_bound, 
+                      "ML_CCZ4::gt22", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::B1!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt22!");
   
   }
   
-  if (CCTK_EQUALS(B2_bound, "scalar"))
+  if (CCTK_EQUALS(gt23_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_B2_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_B2_bound < 0) handle_B2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B2_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_B2_bound ,B2_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_gt23_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt23_bound < 0) handle_gt23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt23_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt23_bound ,gt23_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B2_bound, 
-                      "ML_CCZ4::B2", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt23_bound, 
+                      "ML_CCZ4::gt23", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::B2!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt23!");
   
   }
   
-  if (CCTK_EQUALS(B3_bound, "scalar"))
+  if (CCTK_EQUALS(gt33_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_B3_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_B3_bound < 0) handle_B3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B3_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_B3_bound ,B3_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_gt33_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_gt33_bound < 0) handle_gt33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt33_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_gt33_bound ,gt33_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B3_bound, 
-                      "ML_CCZ4::B3", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt33_bound, 
+                      "ML_CCZ4::gt33", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::B3!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt33!");
   
   }
   
@@ -1503,139 +1452,156 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(alpha_bound, "scalar"))
+  if (CCTK_EQUALS(trK_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_alpha_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_alpha_bound < 0) handle_alpha_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_alpha_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_alpha_bound ,alpha_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_trK_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_trK_bound < 0) handle_trK_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_trK_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_trK_bound ,trK_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_alpha_bound, 
-                      "ML_CCZ4::alpha", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_trK_bound, 
+                      "ML_CCZ4::trK", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::alpha!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::trK!");
   
   }
   
-  if (CCTK_EQUALS(phi_bound, "scalar"))
+  if (CCTK_EQUALS(At11_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_phi_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_phi_bound < 0) handle_phi_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_phi_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_phi_bound ,phi_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_At11_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At11_bound < 0) handle_At11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At11_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At11_bound ,At11_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_phi_bound, 
-                      "ML_CCZ4::phi", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At11_bound, 
+                      "ML_CCZ4::At11", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::phi!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At11!");
   
   }
   
-  if (CCTK_EQUALS(gt11_bound, "scalar"))
+  if (CCTK_EQUALS(At12_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_gt11_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt11_bound < 0) handle_gt11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt11_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt11_bound ,gt11_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_At12_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At12_bound < 0) handle_At12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At12_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At12_bound ,At12_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt11_bound, 
-                      "ML_CCZ4::gt11", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At12_bound, 
+                      "ML_CCZ4::At12", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt11!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At12!");
   
   }
   
-  if (CCTK_EQUALS(gt12_bound, "scalar"))
+  if (CCTK_EQUALS(At13_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_gt12_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt12_bound < 0) handle_gt12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt12_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt12_bound ,gt12_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_At13_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At13_bound < 0) handle_At13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At13_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At13_bound ,At13_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt12_bound, 
-                      "ML_CCZ4::gt12", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At13_bound, 
+                      "ML_CCZ4::At13", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt12!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At13!");
   
   }
   
-  if (CCTK_EQUALS(gt13_bound, "scalar"))
+  if (CCTK_EQUALS(At22_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_gt13_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt13_bound < 0) handle_gt13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt13_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt13_bound ,gt13_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_At22_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At22_bound < 0) handle_At22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At22_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At22_bound ,At22_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt13_bound, 
-                      "ML_CCZ4::gt13", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At22_bound, 
+                      "ML_CCZ4::At22", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt13!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At22!");
   
   }
   
-  if (CCTK_EQUALS(gt22_bound, "scalar"))
+  if (CCTK_EQUALS(At23_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_gt22_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt22_bound < 0) handle_gt22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt22_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt22_bound ,gt22_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_At23_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At23_bound < 0) handle_At23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At23_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At23_bound ,At23_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt22_bound, 
-                      "ML_CCZ4::gt22", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At23_bound, 
+                      "ML_CCZ4::At23", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt22!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At23!");
   
   }
   
-  if (CCTK_EQUALS(gt23_bound, "scalar"))
+  if (CCTK_EQUALS(At33_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_gt23_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt23_bound < 0) handle_gt23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt23_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt23_bound ,gt23_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_At33_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_At33_bound < 0) handle_At33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At33_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_At33_bound ,At33_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt23_bound, 
-                      "ML_CCZ4::gt23", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At33_bound, 
+                      "ML_CCZ4::At33", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt23!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::At33!");
   
   }
   
-  if (CCTK_EQUALS(gt33_bound, "scalar"))
+  if (CCTK_EQUALS(alpha_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_gt33_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_gt33_bound < 0) handle_gt33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt33_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_gt33_bound ,gt33_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_alpha_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_alpha_bound < 0) handle_alpha_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_alpha_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_alpha_bound ,alpha_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt33_bound, 
-                      "ML_CCZ4::gt33", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_alpha_bound, 
+                      "ML_CCZ4::alpha", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::gt33!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::alpha!");
+  
+  }
+  
+  if (CCTK_EQUALS(A_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_A_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_A_bound < 0) handle_A_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_A_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_A_bound ,A_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_A_bound, 
+                      "ML_CCZ4::A", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::A!");
   
   }
   
@@ -1690,37 +1656,71 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(Theta_bound, "scalar"))
+  if (CCTK_EQUALS(B1_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_Theta_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_Theta_bound < 0) handle_Theta_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_Theta_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_Theta_bound ,Theta_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_B1_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_B1_bound < 0) handle_B1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_B1_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_B1_bound ,B1_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_Theta_bound, 
-                      "ML_CCZ4::Theta", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B1_bound, 
+                      "ML_CCZ4::B1", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::Theta!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::B1!");
   
   }
   
-  if (CCTK_EQUALS(trK_bound, "scalar"))
+  if (CCTK_EQUALS(B2_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_trK_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_trK_bound < 0) handle_trK_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_trK_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_trK_bound ,trK_bound_scalar, "SCALAR") < 0)
+    static CCTK_INT handle_B2_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_B2_bound < 0) handle_B2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_B2_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_B2_bound ,B2_bound_scalar, "SCALAR") < 0)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_trK_bound, 
-                      "ML_CCZ4::trK", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B2_bound, 
+                      "ML_CCZ4::B2", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::trK!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::B2!");
+  
+  }
+  
+  if (CCTK_EQUALS(B3_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_B3_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_B3_bound < 0) handle_B3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_B3_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_B3_bound ,B3_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B3_bound, 
+                      "ML_CCZ4::B3", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::B3!");
+  
+  }
+  
+  if (CCTK_EQUALS(Theta_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_Theta_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_Theta_bound < 0) handle_Theta_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_Theta_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_Theta_bound ,Theta_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_Theta_bound, 
+                      "ML_CCZ4::Theta", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_CCZ4::Theta!");
   
   }
   return;
@@ -1729,55 +1729,110 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
 
 
 /* template for entries in parameter file:
-#$bound$#ML_CCZ4::ML_curv_bound       = "skip"
-#$bound$#ML_CCZ4::ML_curv_bound_speed = 1.0
-#$bound$#ML_CCZ4::ML_curv_bound_limit = 0.0
-#$bound$#ML_CCZ4::ML_curv_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::ML_dtlapse_bound       = "skip"
-#$bound$#ML_CCZ4::ML_dtlapse_bound_speed = 1.0
-#$bound$#ML_CCZ4::ML_dtlapse_bound_limit = 0.0
-#$bound$#ML_CCZ4::ML_dtlapse_bound_scalar = 0.0
+#$bound$#ML_CCZ4::ML_log_confac_bound       = "skip"
+#$bound$#ML_CCZ4::ML_log_confac_bound_speed = 1.0
+#$bound$#ML_CCZ4::ML_log_confac_bound_limit = 0.0
+#$bound$#ML_CCZ4::ML_log_confac_bound_scalar = 0.0
 
-#$bound$#ML_CCZ4::ML_dtshift_bound       = "skip"
-#$bound$#ML_CCZ4::ML_dtshift_bound_speed = 1.0
-#$bound$#ML_CCZ4::ML_dtshift_bound_limit = 0.0
-#$bound$#ML_CCZ4::ML_dtshift_bound_scalar = 0.0
+#$bound$#ML_CCZ4::ML_metric_bound       = "skip"
+#$bound$#ML_CCZ4::ML_metric_bound_speed = 1.0
+#$bound$#ML_CCZ4::ML_metric_bound_limit = 0.0
+#$bound$#ML_CCZ4::ML_metric_bound_scalar = 0.0
 
 #$bound$#ML_CCZ4::ML_Gamma_bound       = "skip"
 #$bound$#ML_CCZ4::ML_Gamma_bound_speed = 1.0
 #$bound$#ML_CCZ4::ML_Gamma_bound_limit = 0.0
 #$bound$#ML_CCZ4::ML_Gamma_bound_scalar = 0.0
 
+#$bound$#ML_CCZ4::ML_trace_curv_bound       = "skip"
+#$bound$#ML_CCZ4::ML_trace_curv_bound_speed = 1.0
+#$bound$#ML_CCZ4::ML_trace_curv_bound_limit = 0.0
+#$bound$#ML_CCZ4::ML_trace_curv_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::ML_curv_bound       = "skip"
+#$bound$#ML_CCZ4::ML_curv_bound_speed = 1.0
+#$bound$#ML_CCZ4::ML_curv_bound_limit = 0.0
+#$bound$#ML_CCZ4::ML_curv_bound_scalar = 0.0
+
 #$bound$#ML_CCZ4::ML_lapse_bound       = "skip"
 #$bound$#ML_CCZ4::ML_lapse_bound_speed = 1.0
 #$bound$#ML_CCZ4::ML_lapse_bound_limit = 0.0
 #$bound$#ML_CCZ4::ML_lapse_bound_scalar = 0.0
 
-#$bound$#ML_CCZ4::ML_log_confac_bound       = "skip"
-#$bound$#ML_CCZ4::ML_log_confac_bound_speed = 1.0
-#$bound$#ML_CCZ4::ML_log_confac_bound_limit = 0.0
-#$bound$#ML_CCZ4::ML_log_confac_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::ML_metric_bound       = "skip"
-#$bound$#ML_CCZ4::ML_metric_bound_speed = 1.0
-#$bound$#ML_CCZ4::ML_metric_bound_limit = 0.0
-#$bound$#ML_CCZ4::ML_metric_bound_scalar = 0.0
+#$bound$#ML_CCZ4::ML_dtlapse_bound       = "skip"
+#$bound$#ML_CCZ4::ML_dtlapse_bound_speed = 1.0
+#$bound$#ML_CCZ4::ML_dtlapse_bound_limit = 0.0
+#$bound$#ML_CCZ4::ML_dtlapse_bound_scalar = 0.0
 
 #$bound$#ML_CCZ4::ML_shift_bound       = "skip"
 #$bound$#ML_CCZ4::ML_shift_bound_speed = 1.0
 #$bound$#ML_CCZ4::ML_shift_bound_limit = 0.0
 #$bound$#ML_CCZ4::ML_shift_bound_scalar = 0.0
 
+#$bound$#ML_CCZ4::ML_dtshift_bound       = "skip"
+#$bound$#ML_CCZ4::ML_dtshift_bound_speed = 1.0
+#$bound$#ML_CCZ4::ML_dtshift_bound_limit = 0.0
+#$bound$#ML_CCZ4::ML_dtshift_bound_scalar = 0.0
+
 #$bound$#ML_CCZ4::ML_Theta_bound       = "skip"
 #$bound$#ML_CCZ4::ML_Theta_bound_speed = 1.0
 #$bound$#ML_CCZ4::ML_Theta_bound_limit = 0.0
 #$bound$#ML_CCZ4::ML_Theta_bound_scalar = 0.0
 
-#$bound$#ML_CCZ4::ML_trace_curv_bound       = "skip"
-#$bound$#ML_CCZ4::ML_trace_curv_bound_speed = 1.0
-#$bound$#ML_CCZ4::ML_trace_curv_bound_limit = 0.0
-#$bound$#ML_CCZ4::ML_trace_curv_bound_scalar = 0.0
+#$bound$#ML_CCZ4::phi_bound       = "skip"
+#$bound$#ML_CCZ4::phi_bound_speed = 1.0
+#$bound$#ML_CCZ4::phi_bound_limit = 0.0
+#$bound$#ML_CCZ4::phi_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::gt11_bound       = "skip"
+#$bound$#ML_CCZ4::gt11_bound_speed = 1.0
+#$bound$#ML_CCZ4::gt11_bound_limit = 0.0
+#$bound$#ML_CCZ4::gt11_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::gt12_bound       = "skip"
+#$bound$#ML_CCZ4::gt12_bound_speed = 1.0
+#$bound$#ML_CCZ4::gt12_bound_limit = 0.0
+#$bound$#ML_CCZ4::gt12_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::gt13_bound       = "skip"
+#$bound$#ML_CCZ4::gt13_bound_speed = 1.0
+#$bound$#ML_CCZ4::gt13_bound_limit = 0.0
+#$bound$#ML_CCZ4::gt13_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::gt22_bound       = "skip"
+#$bound$#ML_CCZ4::gt22_bound_speed = 1.0
+#$bound$#ML_CCZ4::gt22_bound_limit = 0.0
+#$bound$#ML_CCZ4::gt22_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::gt23_bound       = "skip"
+#$bound$#ML_CCZ4::gt23_bound_speed = 1.0
+#$bound$#ML_CCZ4::gt23_bound_limit = 0.0
+#$bound$#ML_CCZ4::gt23_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::gt33_bound       = "skip"
+#$bound$#ML_CCZ4::gt33_bound_speed = 1.0
+#$bound$#ML_CCZ4::gt33_bound_limit = 0.0
+#$bound$#ML_CCZ4::gt33_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::Xt1_bound       = "skip"
+#$bound$#ML_CCZ4::Xt1_bound_speed = 1.0
+#$bound$#ML_CCZ4::Xt1_bound_limit = 0.0
+#$bound$#ML_CCZ4::Xt1_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::Xt2_bound       = "skip"
+#$bound$#ML_CCZ4::Xt2_bound_speed = 1.0
+#$bound$#ML_CCZ4::Xt2_bound_limit = 0.0
+#$bound$#ML_CCZ4::Xt2_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::Xt3_bound       = "skip"
+#$bound$#ML_CCZ4::Xt3_bound_speed = 1.0
+#$bound$#ML_CCZ4::Xt3_bound_limit = 0.0
+#$bound$#ML_CCZ4::Xt3_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::trK_bound       = "skip"
+#$bound$#ML_CCZ4::trK_bound_speed = 1.0
+#$bound$#ML_CCZ4::trK_bound_limit = 0.0
+#$bound$#ML_CCZ4::trK_bound_scalar = 0.0
 
 #$bound$#ML_CCZ4::At11_bound       = "skip"
 #$bound$#ML_CCZ4::At11_bound_speed = 1.0
@@ -1809,80 +1864,15 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
 #$bound$#ML_CCZ4::At33_bound_limit = 0.0
 #$bound$#ML_CCZ4::At33_bound_scalar = 0.0
 
-#$bound$#ML_CCZ4::A_bound       = "skip"
-#$bound$#ML_CCZ4::A_bound_speed = 1.0
-#$bound$#ML_CCZ4::A_bound_limit = 0.0
-#$bound$#ML_CCZ4::A_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::B1_bound       = "skip"
-#$bound$#ML_CCZ4::B1_bound_speed = 1.0
-#$bound$#ML_CCZ4::B1_bound_limit = 0.0
-#$bound$#ML_CCZ4::B1_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::B2_bound       = "skip"
-#$bound$#ML_CCZ4::B2_bound_speed = 1.0
-#$bound$#ML_CCZ4::B2_bound_limit = 0.0
-#$bound$#ML_CCZ4::B2_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::B3_bound       = "skip"
-#$bound$#ML_CCZ4::B3_bound_speed = 1.0
-#$bound$#ML_CCZ4::B3_bound_limit = 0.0
-#$bound$#ML_CCZ4::B3_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::Xt1_bound       = "skip"
-#$bound$#ML_CCZ4::Xt1_bound_speed = 1.0
-#$bound$#ML_CCZ4::Xt1_bound_limit = 0.0
-#$bound$#ML_CCZ4::Xt1_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::Xt2_bound       = "skip"
-#$bound$#ML_CCZ4::Xt2_bound_speed = 1.0
-#$bound$#ML_CCZ4::Xt2_bound_limit = 0.0
-#$bound$#ML_CCZ4::Xt2_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::Xt3_bound       = "skip"
-#$bound$#ML_CCZ4::Xt3_bound_speed = 1.0
-#$bound$#ML_CCZ4::Xt3_bound_limit = 0.0
-#$bound$#ML_CCZ4::Xt3_bound_scalar = 0.0
-
 #$bound$#ML_CCZ4::alpha_bound       = "skip"
 #$bound$#ML_CCZ4::alpha_bound_speed = 1.0
 #$bound$#ML_CCZ4::alpha_bound_limit = 0.0
 #$bound$#ML_CCZ4::alpha_bound_scalar = 0.0
 
-#$bound$#ML_CCZ4::phi_bound       = "skip"
-#$bound$#ML_CCZ4::phi_bound_speed = 1.0
-#$bound$#ML_CCZ4::phi_bound_limit = 0.0
-#$bound$#ML_CCZ4::phi_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::gt11_bound       = "skip"
-#$bound$#ML_CCZ4::gt11_bound_speed = 1.0
-#$bound$#ML_CCZ4::gt11_bound_limit = 0.0
-#$bound$#ML_CCZ4::gt11_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::gt12_bound       = "skip"
-#$bound$#ML_CCZ4::gt12_bound_speed = 1.0
-#$bound$#ML_CCZ4::gt12_bound_limit = 0.0
-#$bound$#ML_CCZ4::gt12_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::gt13_bound       = "skip"
-#$bound$#ML_CCZ4::gt13_bound_speed = 1.0
-#$bound$#ML_CCZ4::gt13_bound_limit = 0.0
-#$bound$#ML_CCZ4::gt13_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::gt22_bound       = "skip"
-#$bound$#ML_CCZ4::gt22_bound_speed = 1.0
-#$bound$#ML_CCZ4::gt22_bound_limit = 0.0
-#$bound$#ML_CCZ4::gt22_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::gt23_bound       = "skip"
-#$bound$#ML_CCZ4::gt23_bound_speed = 1.0
-#$bound$#ML_CCZ4::gt23_bound_limit = 0.0
-#$bound$#ML_CCZ4::gt23_bound_scalar = 0.0
-
-#$bound$#ML_CCZ4::gt33_bound       = "skip"
-#$bound$#ML_CCZ4::gt33_bound_speed = 1.0
-#$bound$#ML_CCZ4::gt33_bound_limit = 0.0
-#$bound$#ML_CCZ4::gt33_bound_scalar = 0.0
+#$bound$#ML_CCZ4::A_bound       = "skip"
+#$bound$#ML_CCZ4::A_bound_speed = 1.0
+#$bound$#ML_CCZ4::A_bound_limit = 0.0
+#$bound$#ML_CCZ4::A_bound_scalar = 0.0
 
 #$bound$#ML_CCZ4::beta1_bound       = "skip"
 #$bound$#ML_CCZ4::beta1_bound_speed = 1.0
@@ -1899,15 +1889,25 @@ extern "C" void ML_CCZ4_SelectBoundConds(CCTK_ARGUMENTS)
 #$bound$#ML_CCZ4::beta3_bound_limit = 0.0
 #$bound$#ML_CCZ4::beta3_bound_scalar = 0.0
 
+#$bound$#ML_CCZ4::B1_bound       = "skip"
+#$bound$#ML_CCZ4::B1_bound_speed = 1.0
+#$bound$#ML_CCZ4::B1_bound_limit = 0.0
+#$bound$#ML_CCZ4::B1_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::B2_bound       = "skip"
+#$bound$#ML_CCZ4::B2_bound_speed = 1.0
+#$bound$#ML_CCZ4::B2_bound_limit = 0.0
+#$bound$#ML_CCZ4::B2_bound_scalar = 0.0
+
+#$bound$#ML_CCZ4::B3_bound       = "skip"
+#$bound$#ML_CCZ4::B3_bound_speed = 1.0
+#$bound$#ML_CCZ4::B3_bound_limit = 0.0
+#$bound$#ML_CCZ4::B3_bound_scalar = 0.0
+
 #$bound$#ML_CCZ4::Theta_bound       = "skip"
 #$bound$#ML_CCZ4::Theta_bound_speed = 1.0
 #$bound$#ML_CCZ4::Theta_bound_limit = 0.0
 #$bound$#ML_CCZ4::Theta_bound_scalar = 0.0
 
-#$bound$#ML_CCZ4::trK_bound       = "skip"
-#$bound$#ML_CCZ4::trK_bound_speed = 1.0
-#$bound$#ML_CCZ4::trK_bound_limit = 0.0
-#$bound$#ML_CCZ4::trK_bound_scalar = 0.0
-
 */
 
diff --git a/ML_CCZ4/src/RegisterSymmetries.cc b/ML_CCZ4/src/RegisterSymmetries.cc
index eef4c88..d11e795 100644
--- a/ML_CCZ4/src/RegisterSymmetries.cc
+++ b/ML_CCZ4/src/RegisterSymmetries.cc
@@ -19,52 +19,37 @@ extern "C" void ML_CCZ4_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At11");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::phi");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt11");
   
   sym[0] = -1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At12");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt12");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At13");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt13");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At22");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt22");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At23");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At33");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt23");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::A");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::B1");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::B2");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::B3");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt33");
   
   sym[0] = -1;
   sym[1] = 1;
@@ -84,42 +69,47 @@ extern "C" void ML_CCZ4_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::alpha");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::phi");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::trK");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt11");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At11");
   
   sym[0] = -1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt12");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At12");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt13");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At13");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt22");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At22");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt23");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At23");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::gt33");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::At33");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::alpha");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::A");
   
   sym[0] = -1;
   sym[1] = 1;
@@ -136,59 +126,69 @@ extern "C" void ML_CCZ4_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[2] = -1;
   SetCartSymVN(cctkGH, sym, "ML_CCZ4::beta3");
   
-  sym[0] = 1;
+  sym[0] = -1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::Theta");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::B1");
+  
+  sym[0] = 1;
+  sym[1] = -1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::B2");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = -1;
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::B3");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::trK");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::Theta");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::cS");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::H");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::cXt1");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::M1");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::cXt2");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::M2");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::cXt3");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::cA");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::M3");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::H");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::cS");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::M1");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::cXt1");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::M2");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::cXt2");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_CCZ4::M3");
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::cXt3");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_CCZ4::cA");
   
 }