Regenerate code (Kranc commit 3237af2566109f099ee78a7effb511a65dc18ae0)

11 files changed, 2240 insertions, 2240 deletions

diff --git a/ML_ADM/src/Boundaries.cc b/ML_ADM/src/Boundaries.cc
index f150f48..bc3f0e5 100644
--- a/ML_ADM/src/Boundaries.cc
+++ b/ML_ADM/src/Boundaries.cc
@@ -32,6 +32,17 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
   
   CCTK_INT ierr CCTK_ATTRIBUTE_UNUSED = 0;
   
+  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_ADM::ML_metric", ML_metric_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register ML_metric_bound BC for ML_ADM::ML_metric!");
+  }
+  
   if (CCTK_EQUALS(ML_curv_bound, "none"  ) ||
       CCTK_EQUALS(ML_curv_bound, "static") ||
       CCTK_EQUALS(ML_curv_bound, "flat"  ) ||
@@ -54,17 +65,6 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register ML_lapse_bound BC for ML_ADM::ML_lapse!");
   }
   
-  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_ADM::ML_metric", ML_metric_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_metric_bound BC for ML_ADM::ML_metric!");
-  }
-  
   if (CCTK_EQUALS(ML_shift_bound, "none"  ) ||
       CCTK_EQUALS(ML_shift_bound, "static") ||
       CCTK_EQUALS(ML_shift_bound, "flat"  ) ||
@@ -76,6 +76,72 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register ML_shift_bound BC for ML_ADM::ML_shift!");
   }
   
+  if (CCTK_EQUALS(g11_bound, "none"  ) ||
+      CCTK_EQUALS(g11_bound, "static") ||
+      CCTK_EQUALS(g11_bound, "flat"  ) ||
+      CCTK_EQUALS(g11_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_ADM::g11", g11_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register g11_bound BC for ML_ADM::g11!");
+  }
+  
+  if (CCTK_EQUALS(g12_bound, "none"  ) ||
+      CCTK_EQUALS(g12_bound, "static") ||
+      CCTK_EQUALS(g12_bound, "flat"  ) ||
+      CCTK_EQUALS(g12_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_ADM::g12", g12_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register g12_bound BC for ML_ADM::g12!");
+  }
+  
+  if (CCTK_EQUALS(g13_bound, "none"  ) ||
+      CCTK_EQUALS(g13_bound, "static") ||
+      CCTK_EQUALS(g13_bound, "flat"  ) ||
+      CCTK_EQUALS(g13_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_ADM::g13", g13_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register g13_bound BC for ML_ADM::g13!");
+  }
+  
+  if (CCTK_EQUALS(g22_bound, "none"  ) ||
+      CCTK_EQUALS(g22_bound, "static") ||
+      CCTK_EQUALS(g22_bound, "flat"  ) ||
+      CCTK_EQUALS(g22_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_ADM::g22", g22_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register g22_bound BC for ML_ADM::g22!");
+  }
+  
+  if (CCTK_EQUALS(g23_bound, "none"  ) ||
+      CCTK_EQUALS(g23_bound, "static") ||
+      CCTK_EQUALS(g23_bound, "flat"  ) ||
+      CCTK_EQUALS(g23_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_ADM::g23", g23_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register g23_bound BC for ML_ADM::g23!");
+  }
+  
+  if (CCTK_EQUALS(g33_bound, "none"  ) ||
+      CCTK_EQUALS(g33_bound, "static") ||
+      CCTK_EQUALS(g33_bound, "flat"  ) ||
+      CCTK_EQUALS(g33_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_ADM::g33", g33_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register g33_bound BC for ML_ADM::g33!");
+  }
+  
   if (CCTK_EQUALS(K11_bound, "none"  ) ||
       CCTK_EQUALS(K11_bound, "static") ||
       CCTK_EQUALS(K11_bound, "flat"  ) ||
@@ -153,72 +219,6 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register alpha_bound BC for ML_ADM::alpha!");
   }
   
-  if (CCTK_EQUALS(g11_bound, "none"  ) ||
-      CCTK_EQUALS(g11_bound, "static") ||
-      CCTK_EQUALS(g11_bound, "flat"  ) ||
-      CCTK_EQUALS(g11_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_ADM::g11", g11_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register g11_bound BC for ML_ADM::g11!");
-  }
-  
-  if (CCTK_EQUALS(g12_bound, "none"  ) ||
-      CCTK_EQUALS(g12_bound, "static") ||
-      CCTK_EQUALS(g12_bound, "flat"  ) ||
-      CCTK_EQUALS(g12_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_ADM::g12", g12_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register g12_bound BC for ML_ADM::g12!");
-  }
-  
-  if (CCTK_EQUALS(g13_bound, "none"  ) ||
-      CCTK_EQUALS(g13_bound, "static") ||
-      CCTK_EQUALS(g13_bound, "flat"  ) ||
-      CCTK_EQUALS(g13_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_ADM::g13", g13_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register g13_bound BC for ML_ADM::g13!");
-  }
-  
-  if (CCTK_EQUALS(g22_bound, "none"  ) ||
-      CCTK_EQUALS(g22_bound, "static") ||
-      CCTK_EQUALS(g22_bound, "flat"  ) ||
-      CCTK_EQUALS(g22_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_ADM::g22", g22_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register g22_bound BC for ML_ADM::g22!");
-  }
-  
-  if (CCTK_EQUALS(g23_bound, "none"  ) ||
-      CCTK_EQUALS(g23_bound, "static") ||
-      CCTK_EQUALS(g23_bound, "flat"  ) ||
-      CCTK_EQUALS(g23_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_ADM::g23", g23_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register g23_bound BC for ML_ADM::g23!");
-  }
-  
-  if (CCTK_EQUALS(g33_bound, "none"  ) ||
-      CCTK_EQUALS(g33_bound, "static") ||
-      CCTK_EQUALS(g33_bound, "flat"  ) ||
-      CCTK_EQUALS(g33_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_ADM::g33", g33_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register g33_bound BC for ML_ADM::g33!");
-  }
-  
   if (CCTK_EQUALS(beta1_bound, "none"  ) ||
       CCTK_EQUALS(beta1_bound, "static") ||
       CCTK_EQUALS(beta1_bound, "flat"  ) ||
@@ -252,6 +252,25 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register beta3_bound BC for ML_ADM::beta3!");
   }
   
+  if (CCTK_EQUALS(ML_metric_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)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    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_metric_bound, 
+                      "ML_ADM::ML_metric", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ML_metric!");
+  
+  }
+  
   if (CCTK_EQUALS(ML_curv_bound, "radiative"))
   {
    /* select radiation boundary condition */
@@ -290,25 +309,6 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(ML_metric_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)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    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_metric_bound, 
-                      "ML_ADM::ML_metric", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ML_metric!");
-  
-  }
-  
   if (CCTK_EQUALS(ML_shift_bound, "radiative"))
   {
    /* select radiation boundary condition */
@@ -328,6 +328,120 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
+  if (CCTK_EQUALS(g11_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_g11_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g11_bound < 0) handle_g11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g11_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g11_bound , g11_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_g11_bound ,g11_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g11_bound, 
+                      "ML_ADM::g11", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g11!");
+  
+  }
+  
+  if (CCTK_EQUALS(g12_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_g12_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g12_bound < 0) handle_g12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g12_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g12_bound , g12_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_g12_bound ,g12_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g12_bound, 
+                      "ML_ADM::g12", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g12!");
+  
+  }
+  
+  if (CCTK_EQUALS(g13_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_g13_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g13_bound < 0) handle_g13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g13_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g13_bound , g13_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_g13_bound ,g13_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g13_bound, 
+                      "ML_ADM::g13", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g13!");
+  
+  }
+  
+  if (CCTK_EQUALS(g22_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_g22_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g22_bound < 0) handle_g22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g22_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g22_bound , g22_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_g22_bound ,g22_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g22_bound, 
+                      "ML_ADM::g22", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g22!");
+  
+  }
+  
+  if (CCTK_EQUALS(g23_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_g23_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g23_bound < 0) handle_g23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g23_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g23_bound , g23_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_g23_bound ,g23_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g23_bound, 
+                      "ML_ADM::g23", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g23!");
+  
+  }
+  
+  if (CCTK_EQUALS(g33_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_g33_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g33_bound < 0) handle_g33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g33_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g33_bound , g33_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_g33_bound ,g33_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g33_bound, 
+                      "ML_ADM::g33", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g33!");
+  
+  }
+  
   if (CCTK_EQUALS(K11_bound, "radiative"))
   {
    /* select radiation boundary condition */
@@ -461,120 +575,6 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(g11_bound, "radiative"))
-  {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_g11_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g11_bound < 0) handle_g11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g11_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g11_bound , g11_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g11_bound ,g11_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g11_bound, 
-                      "ML_ADM::g11", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g11!");
-  
-  }
-  
-  if (CCTK_EQUALS(g12_bound, "radiative"))
-  {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_g12_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g12_bound < 0) handle_g12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g12_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g12_bound , g12_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g12_bound ,g12_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g12_bound, 
-                      "ML_ADM::g12", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g12!");
-  
-  }
-  
-  if (CCTK_EQUALS(g13_bound, "radiative"))
-  {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_g13_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g13_bound < 0) handle_g13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g13_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g13_bound , g13_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g13_bound ,g13_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g13_bound, 
-                      "ML_ADM::g13", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g13!");
-  
-  }
-  
-  if (CCTK_EQUALS(g22_bound, "radiative"))
-  {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_g22_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g22_bound < 0) handle_g22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g22_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g22_bound , g22_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g22_bound ,g22_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g22_bound, 
-                      "ML_ADM::g22", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g22!");
-  
-  }
-  
-  if (CCTK_EQUALS(g23_bound, "radiative"))
-  {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_g23_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g23_bound < 0) handle_g23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g23_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g23_bound , g23_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g23_bound ,g23_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g23_bound, 
-                      "ML_ADM::g23", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g23!");
-  
-  }
-  
-  if (CCTK_EQUALS(g33_bound, "radiative"))
-  {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_g33_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g33_bound < 0) handle_g33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g33_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g33_bound , g33_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g33_bound ,g33_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g33_bound, 
-                      "ML_ADM::g33", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g33!");
-  
-  }
-  
   if (CCTK_EQUALS(beta1_bound, "radiative"))
   {
    /* select radiation boundary condition */
@@ -632,6 +632,23 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
+  if (CCTK_EQUALS(ML_metric_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)
+        CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_metric_bound, 
+                      "ML_ADM::ML_metric", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ML_metric!");
+  
+  }
+  
   if (CCTK_EQUALS(ML_curv_bound, "scalar"))
   {
    /* select scalar boundary condition */
@@ -666,23 +683,6 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(ML_metric_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)
-        CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_metric_bound, 
-                      "ML_ADM::ML_metric", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ML_metric!");
-  
-  }
-  
   if (CCTK_EQUALS(ML_shift_bound, "scalar"))
   {
    /* select scalar boundary condition */
@@ -700,6 +700,108 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
+  if (CCTK_EQUALS(g11_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_g11_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g11_bound < 0) handle_g11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g11_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g11_bound ,g11_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g11_bound, 
+                      "ML_ADM::g11", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g11!");
+  
+  }
+  
+  if (CCTK_EQUALS(g12_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_g12_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g12_bound < 0) handle_g12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g12_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g12_bound ,g12_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g12_bound, 
+                      "ML_ADM::g12", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g12!");
+  
+  }
+  
+  if (CCTK_EQUALS(g13_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_g13_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g13_bound < 0) handle_g13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g13_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g13_bound ,g13_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g13_bound, 
+                      "ML_ADM::g13", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g13!");
+  
+  }
+  
+  if (CCTK_EQUALS(g22_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_g22_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g22_bound < 0) handle_g22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g22_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g22_bound ,g22_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g22_bound, 
+                      "ML_ADM::g22", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g22!");
+  
+  }
+  
+  if (CCTK_EQUALS(g23_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_g23_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g23_bound < 0) handle_g23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g23_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g23_bound ,g23_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g23_bound, 
+                      "ML_ADM::g23", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g23!");
+  
+  }
+  
+  if (CCTK_EQUALS(g33_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_g33_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_g33_bound < 0) handle_g33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_g33_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_g33_bound ,g33_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g33_bound, 
+                      "ML_ADM::g33", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g33!");
+  
+  }
+  
   if (CCTK_EQUALS(K11_bound, "scalar"))
   {
    /* select scalar boundary condition */
@@ -819,108 +921,6 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(g11_bound, "scalar"))
-  {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_g11_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g11_bound < 0) handle_g11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g11_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g11_bound ,g11_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g11_bound, 
-                      "ML_ADM::g11", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g11!");
-  
-  }
-  
-  if (CCTK_EQUALS(g12_bound, "scalar"))
-  {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_g12_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g12_bound < 0) handle_g12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g12_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g12_bound ,g12_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g12_bound, 
-                      "ML_ADM::g12", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g12!");
-  
-  }
-  
-  if (CCTK_EQUALS(g13_bound, "scalar"))
-  {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_g13_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g13_bound < 0) handle_g13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g13_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g13_bound ,g13_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g13_bound, 
-                      "ML_ADM::g13", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g13!");
-  
-  }
-  
-  if (CCTK_EQUALS(g22_bound, "scalar"))
-  {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_g22_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g22_bound < 0) handle_g22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g22_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g22_bound ,g22_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g22_bound, 
-                      "ML_ADM::g22", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g22!");
-  
-  }
-  
-  if (CCTK_EQUALS(g23_bound, "scalar"))
-  {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_g23_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g23_bound < 0) handle_g23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g23_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g23_bound ,g23_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g23_bound, 
-                      "ML_ADM::g23", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g23!");
-  
-  }
-  
-  if (CCTK_EQUALS(g33_bound, "scalar"))
-  {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_g33_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_g33_bound < 0) handle_g33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g33_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_g33_bound ,g33_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g33_bound, 
-                      "ML_ADM::g33", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g33!");
-  
-  }
-  
   if (CCTK_EQUALS(beta1_bound, "scalar"))
   {
    /* select scalar boundary condition */
@@ -977,6 +977,11 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
 
 
 /* template for entries in parameter file:
+#$bound$#ML_ADM::ML_metric_bound       = "skip"
+#$bound$#ML_ADM::ML_metric_bound_speed = 1.0
+#$bound$#ML_ADM::ML_metric_bound_limit = 0.0
+#$bound$#ML_ADM::ML_metric_bound_scalar = 0.0
+
 #$bound$#ML_ADM::ML_curv_bound       = "skip"
 #$bound$#ML_ADM::ML_curv_bound_speed = 1.0
 #$bound$#ML_ADM::ML_curv_bound_limit = 0.0
@@ -987,16 +992,41 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
 #$bound$#ML_ADM::ML_lapse_bound_limit = 0.0
 #$bound$#ML_ADM::ML_lapse_bound_scalar = 0.0
 
-#$bound$#ML_ADM::ML_metric_bound       = "skip"
-#$bound$#ML_ADM::ML_metric_bound_speed = 1.0
-#$bound$#ML_ADM::ML_metric_bound_limit = 0.0
-#$bound$#ML_ADM::ML_metric_bound_scalar = 0.0
-
 #$bound$#ML_ADM::ML_shift_bound       = "skip"
 #$bound$#ML_ADM::ML_shift_bound_speed = 1.0
 #$bound$#ML_ADM::ML_shift_bound_limit = 0.0
 #$bound$#ML_ADM::ML_shift_bound_scalar = 0.0
 
+#$bound$#ML_ADM::g11_bound       = "skip"
+#$bound$#ML_ADM::g11_bound_speed = 1.0
+#$bound$#ML_ADM::g11_bound_limit = 0.0
+#$bound$#ML_ADM::g11_bound_scalar = 0.0
+
+#$bound$#ML_ADM::g12_bound       = "skip"
+#$bound$#ML_ADM::g12_bound_speed = 1.0
+#$bound$#ML_ADM::g12_bound_limit = 0.0
+#$bound$#ML_ADM::g12_bound_scalar = 0.0
+
+#$bound$#ML_ADM::g13_bound       = "skip"
+#$bound$#ML_ADM::g13_bound_speed = 1.0
+#$bound$#ML_ADM::g13_bound_limit = 0.0
+#$bound$#ML_ADM::g13_bound_scalar = 0.0
+
+#$bound$#ML_ADM::g22_bound       = "skip"
+#$bound$#ML_ADM::g22_bound_speed = 1.0
+#$bound$#ML_ADM::g22_bound_limit = 0.0
+#$bound$#ML_ADM::g22_bound_scalar = 0.0
+
+#$bound$#ML_ADM::g23_bound       = "skip"
+#$bound$#ML_ADM::g23_bound_speed = 1.0
+#$bound$#ML_ADM::g23_bound_limit = 0.0
+#$bound$#ML_ADM::g23_bound_scalar = 0.0
+
+#$bound$#ML_ADM::g33_bound       = "skip"
+#$bound$#ML_ADM::g33_bound_speed = 1.0
+#$bound$#ML_ADM::g33_bound_limit = 0.0
+#$bound$#ML_ADM::g33_bound_scalar = 0.0
+
 #$bound$#ML_ADM::K11_bound       = "skip"
 #$bound$#ML_ADM::K11_bound_speed = 1.0
 #$bound$#ML_ADM::K11_bound_limit = 0.0
@@ -1032,36 +1062,6 @@ extern "C" void ML_ADM_SelectBoundConds(CCTK_ARGUMENTS)
 #$bound$#ML_ADM::alpha_bound_limit = 0.0
 #$bound$#ML_ADM::alpha_bound_scalar = 0.0
 
-#$bound$#ML_ADM::g11_bound       = "skip"
-#$bound$#ML_ADM::g11_bound_speed = 1.0
-#$bound$#ML_ADM::g11_bound_limit = 0.0
-#$bound$#ML_ADM::g11_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g12_bound       = "skip"
-#$bound$#ML_ADM::g12_bound_speed = 1.0
-#$bound$#ML_ADM::g12_bound_limit = 0.0
-#$bound$#ML_ADM::g12_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g13_bound       = "skip"
-#$bound$#ML_ADM::g13_bound_speed = 1.0
-#$bound$#ML_ADM::g13_bound_limit = 0.0
-#$bound$#ML_ADM::g13_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g22_bound       = "skip"
-#$bound$#ML_ADM::g22_bound_speed = 1.0
-#$bound$#ML_ADM::g22_bound_limit = 0.0
-#$bound$#ML_ADM::g22_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g23_bound       = "skip"
-#$bound$#ML_ADM::g23_bound_speed = 1.0
-#$bound$#ML_ADM::g23_bound_limit = 0.0
-#$bound$#ML_ADM::g23_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g33_bound       = "skip"
-#$bound$#ML_ADM::g33_bound_speed = 1.0
-#$bound$#ML_ADM::g33_bound_limit = 0.0
-#$bound$#ML_ADM::g33_bound_scalar = 0.0
-
 #$bound$#ML_ADM::beta1_bound       = "skip"
 #$bound$#ML_ADM::beta1_bound_speed = 1.0
 #$bound$#ML_ADM::beta1_bound_limit = 0.0
diff --git a/ML_ADM/src/RegisterSymmetries.cc b/ML_ADM/src/RegisterSymmetries.cc
index 0d05f97..0f972fb 100644
--- a/ML_ADM/src/RegisterSymmetries.cc
+++ b/ML_ADM/src/RegisterSymmetries.cc
@@ -19,67 +19,67 @@ extern "C" void ML_ADM_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K11");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::g11");
   
   sym[0] = -1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K12");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::g12");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K13");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::g13");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K22");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::g22");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K23");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K33");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::g23");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::alpha");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::g33");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g11");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::K11");
   
   sym[0] = -1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g12");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::K12");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g13");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::K13");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g22");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::K22");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g23");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::K23");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g33");
+  SetCartSymVN(cctkGH, sym, "ML_ADM::K33");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_ADM::alpha");
   
   sym[0] = -1;
   sym[1] = 1;
diff --git a/ML_ADMQuantities/src/RegisterSymmetries.cc b/ML_ADMQuantities/src/RegisterSymmetries.cc
index c8d33d2..0e6af62 100644
--- a/ML_ADMQuantities/src/RegisterSymmetries.cc
+++ b/ML_ADMQuantities/src/RegisterSymmetries.cc
@@ -16,6 +16,11 @@ extern "C" void ML_ADMQuantities_RegisterSymmetries(CCTK_ARGUMENTS)
   
   
   /* Register symmetries of grid functions */
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_ADMQuantities::Madm");
+  
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = 1;
@@ -31,9 +36,4 @@ extern "C" void ML_ADMQuantities_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[2] = -1;
   SetCartSymVN(cctkGH, sym, "ML_ADMQuantities::Jadm3");
   
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADMQuantities::Madm");
-  
 }
diff --git a/ML_BSSN/src/Boundaries.cc b/ML_BSSN/src/Boundaries.cc
index e720864..345827a 100644
--- a/ML_BSSN/src/Boundaries.cc
+++ b/ML_BSSN/src/Boundaries.cc
@@ -32,37 +32,26 @@ extern "C" void ML_BSSN_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_BSSN::ML_curv", ML_curv_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_curv_bound BC for ML_BSSN::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_BSSN::ML_dtlapse", ML_dtlapse_bound);
+                      "ML_BSSN::ML_log_confac", ML_log_confac_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_dtlapse_bound BC for ML_BSSN::ML_dtlapse!");
+       CCTK_WARN(0, "Failed to register ML_log_confac_bound BC for ML_BSSN::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_BSSN::ML_dtshift", ML_dtshift_bound);
+                      "ML_BSSN::ML_metric", ML_metric_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_dtshift_bound BC for ML_BSSN::ML_dtshift!");
+       CCTK_WARN(0, "Failed to register ML_metric_bound BC for ML_BSSN::ML_metric!");
   }
   
   if (CCTK_EQUALS(ML_Gamma_bound, "none"  ) ||
@@ -76,6 +65,28 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register ML_Gamma_bound BC for ML_BSSN::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_BSSN::ML_trace_curv", ML_trace_curv_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register ML_trace_curv_bound BC for ML_BSSN::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_BSSN::ML_curv", ML_curv_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register ML_curv_bound BC for ML_BSSN::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_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register ML_lapse_bound BC for ML_BSSN::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_BSSN::ML_log_confac", ML_log_confac_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_log_confac_bound BC for ML_BSSN::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_BSSN::ML_metric", ML_metric_bound);
+                      "ML_BSSN::ML_dtlapse", ML_dtlapse_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_metric_bound BC for ML_BSSN::ML_metric!");
+       CCTK_WARN(0, "Failed to register ML_dtlapse_bound BC for ML_BSSN::ML_dtlapse!");
   }
   
   if (CCTK_EQUALS(ML_shift_bound, "none"  ) ||
@@ -120,125 +120,92 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register ML_shift_bound BC for ML_BSSN::ML_shift!");
   }
   
-  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"  ) )
+  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_BSSN::ML_trace_curv", ML_trace_curv_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ML_trace_curv_bound BC for ML_BSSN::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_BSSN::At11", At11_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At11_bound BC for ML_BSSN::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_BSSN::At12", At12_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At12_bound BC for ML_BSSN::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_BSSN::At13", At13_bound);
+                      "ML_BSSN::ML_dtshift", ML_dtshift_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At13_bound BC for ML_BSSN::At13!");
+       CCTK_WARN(0, "Failed to register ML_dtshift_bound BC for ML_BSSN::ML_dtshift!");
   }
   
-  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_BSSN::At22", At22_bound);
+                      "ML_BSSN::phi", phi_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At22_bound BC for ML_BSSN::At22!");
+       CCTK_WARN(0, "Failed to register phi_bound BC for ML_BSSN::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_BSSN::At23", At23_bound);
+                      "ML_BSSN::gt11", gt11_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At23_bound BC for ML_BSSN::At23!");
+       CCTK_WARN(0, "Failed to register gt11_bound BC for ML_BSSN::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_BSSN::At33", At33_bound);
+                      "ML_BSSN::gt12", gt12_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register At33_bound BC for ML_BSSN::At33!");
+       CCTK_WARN(0, "Failed to register gt12_bound BC for ML_BSSN::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_BSSN::A", A_bound);
+                      "ML_BSSN::gt13", gt13_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register A_bound BC for ML_BSSN::A!");
+       CCTK_WARN(0, "Failed to register gt13_bound BC for ML_BSSN::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_BSSN::B1", B1_bound);
+                      "ML_BSSN::gt22", gt22_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register B1_bound BC for ML_BSSN::B1!");
+       CCTK_WARN(0, "Failed to register gt22_bound BC for ML_BSSN::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_BSSN::B2", B2_bound);
+                      "ML_BSSN::gt23", gt23_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register B2_bound BC for ML_BSSN::B2!");
+       CCTK_WARN(0, "Failed to register gt23_bound BC for ML_BSSN::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_BSSN::B3", B3_bound);
+                      "ML_BSSN::gt33", gt33_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register B3_bound BC for ML_BSSN::B3!");
+       CCTK_WARN(0, "Failed to register gt33_bound BC for ML_BSSN::gt33!");
   }
   
   if (CCTK_EQUALS(Xt1_bound, "none"  ) ||
@@ -274,92 +241,103 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register Xt3_bound BC for ML_BSSN::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_BSSN::alpha", alpha_bound);
+                      "ML_BSSN::trK", trK_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register alpha_bound BC for ML_BSSN::alpha!");
+       CCTK_WARN(0, "Failed to register trK_bound BC for ML_BSSN::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_BSSN::phi", phi_bound);
+                      "ML_BSSN::At11", At11_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register phi_bound BC for ML_BSSN::phi!");
+       CCTK_WARN(0, "Failed to register At11_bound BC for ML_BSSN::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_BSSN::gt11", gt11_bound);
+                      "ML_BSSN::At12", At12_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt11_bound BC for ML_BSSN::gt11!");
+       CCTK_WARN(0, "Failed to register At12_bound BC for ML_BSSN::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_BSSN::gt12", gt12_bound);
+                      "ML_BSSN::At13", At13_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt12_bound BC for ML_BSSN::gt12!");
+       CCTK_WARN(0, "Failed to register At13_bound BC for ML_BSSN::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_BSSN::gt13", gt13_bound);
+                      "ML_BSSN::At22", At22_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt13_bound BC for ML_BSSN::gt13!");
+       CCTK_WARN(0, "Failed to register At22_bound BC for ML_BSSN::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_BSSN::gt22", gt22_bound);
+                      "ML_BSSN::At23", At23_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt22_bound BC for ML_BSSN::gt22!");
+       CCTK_WARN(0, "Failed to register At23_bound BC for ML_BSSN::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_BSSN::gt23", gt23_bound);
+                      "ML_BSSN::At33", At33_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt23_bound BC for ML_BSSN::gt23!");
+       CCTK_WARN(0, "Failed to register At33_bound BC for ML_BSSN::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_BSSN::gt33", gt33_bound);
+                      "ML_BSSN::alpha", alpha_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register gt33_bound BC for ML_BSSN::gt33!");
+       CCTK_WARN(0, "Failed to register alpha_bound BC for ML_BSSN::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_BSSN::A", A_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register A_bound BC for ML_BSSN::A!");
   }
   
   if (CCTK_EQUALS(beta1_bound, "none"  ) ||
@@ -395,71 +373,74 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register beta3_bound BC for ML_BSSN::beta3!");
   }
   
-  if (CCTK_EQUALS(trK_bound, "none"  ) ||
-      CCTK_EQUALS(trK_bound, "static") ||
-      CCTK_EQUALS(trK_bound, "flat"  ) ||
-      CCTK_EQUALS(trK_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_BSSN::trK", trK_bound);
+                      "ML_BSSN::B1", B1_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register trK_bound BC for ML_BSSN::trK!");
+       CCTK_WARN(0, "Failed to register B1_bound BC for ML_BSSN::B1!");
   }
   
-  if (CCTK_EQUALS(ML_curv_bound, "radiative"))
+  if (CCTK_EQUALS(B2_bound, "none"  ) ||
+      CCTK_EQUALS(B2_bound, "static") ||
+      CCTK_EQUALS(B2_bound, "flat"  ) ||
+      CCTK_EQUALS(B2_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_BSSN::ML_curv", "Radiation");
-  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_BSSN::B2", B2_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_curv!");
+       CCTK_WARN(0, "Failed to register B2_bound BC for ML_BSSN::B2!");
+  }
   
+  if (CCTK_EQUALS(B3_bound, "none"  ) ||
+      CCTK_EQUALS(B3_bound, "static") ||
+      CCTK_EQUALS(B3_bound, "flat"  ) ||
+      CCTK_EQUALS(B3_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_BSSN::B3", B3_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register B3_bound BC for ML_BSSN::B3!");
   }
   
-  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_BSSN::ML_dtlapse", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_log_confac_bound, 
+                      "ML_BSSN::ML_log_confac", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_dtlapse!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::ML_dtshift", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_metric_bound, 
+                      "ML_BSSN::ML_metric", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_dtshift!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_metric!");
   
   }
   
@@ -482,288 +463,250 @@ extern "C" void ML_BSSN_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_BSSN::ML_lapse", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_trace_curv_bound, 
+                      "ML_BSSN::ML_trace_curv", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_lapse!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::ML_log_confac", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_curv_bound, 
+                      "ML_BSSN::ML_curv", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_log_confac!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::ML_metric", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_lapse_bound, 
+                      "ML_BSSN::ML_lapse", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_metric!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::ML_shift", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtlapse_bound, 
+                      "ML_BSSN::ML_dtlapse", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_shift!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_dtlapse!");
   
   }
   
-  if (CCTK_EQUALS(ML_trace_curv_bound, "radiative"))
+  if (CCTK_EQUALS(ML_shift_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_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_trace_curv_bound ,ML_trace_curv_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_trace_curv_bound, 
-                      "ML_BSSN::ML_trace_curv", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::At11", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::At12", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_shift_bound, 
+                      "ML_BSSN::ML_shift", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At12!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_shift!");
   
   }
   
-  if (CCTK_EQUALS(At13_bound, "radiative"))
+  if (CCTK_EQUALS(ML_dtshift_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_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_At13_bound ,At13_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
+    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_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At13_bound, 
-                      "ML_BSSN::At13", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtshift_bound, 
+                      "ML_BSSN::ML_dtshift", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At13!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_dtshift!");
   
   }
   
-  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_BSSN::At22", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_phi_bound, 
+                      "ML_BSSN::phi", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At22!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::At23", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt11_bound, 
+                      "ML_BSSN::gt11", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At23!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::At33", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt12_bound, 
+                      "ML_BSSN::gt12", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At33!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::A", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt13_bound, 
+                      "ML_BSSN::gt13", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::A!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::B1", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt22_bound, 
+                      "ML_BSSN::gt22", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::B1!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::B2", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt23_bound, 
+                      "ML_BSSN::gt23", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::B2!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::B3", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt33_bound, 
+                      "ML_BSSN::gt33", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::B3!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt33!");
   
   }
   
@@ -824,155 +767,174 @@ extern "C" void ML_BSSN_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_BSSN::alpha", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_trK_bound, 
+                      "ML_BSSN::trK", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::alpha!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::phi", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At11_bound, 
+                      "ML_BSSN::At11", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::phi!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::gt11", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At12_bound, 
+                      "ML_BSSN::At12", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt11!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::gt12", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At13_bound, 
+                      "ML_BSSN::At13", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt12!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::gt13", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At22_bound, 
+                      "ML_BSSN::At22", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt13!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::gt22", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At23_bound, 
+                      "ML_BSSN::At23", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt22!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::gt23", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At33_bound, 
+                      "ML_BSSN::At33", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt23!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::gt33", "Radiation");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_alpha_bound, 
+                      "ML_BSSN::alpha", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt33!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::A", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::A!");
   
   }
   
@@ -1033,107 +995,60 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(trK_bound, "radiative"))
+  if (CCTK_EQUALS(B1_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_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_trK_bound ,trK_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_trK_bound, 
-                      "ML_BSSN::trK", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::trK!");
-  
-  }
-  
-  if (CCTK_EQUALS(ML_curv_bound, "scalar"))
-  {
-   /* 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!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_curv_bound, 
-                      "ML_BSSN::ML_curv", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_curv!");
-  
-  }
-  
-  if (CCTK_EQUALS(ML_dtlapse_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)
-        CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtlapse_bound, 
-                      "ML_BSSN::ML_dtlapse", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_dtlapse!");
-  
-  }
-  
-  if (CCTK_EQUALS(ML_dtshift_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)
-        CCTK_WARN(0, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtshift_bound, 
-                      "ML_BSSN::ML_dtshift", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B1_bound, 
+                      "ML_BSSN::B1", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_dtshift!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::B1!");
   
   }
   
-  if (CCTK_EQUALS(ML_Gamma_bound, "scalar"))
+  if (CCTK_EQUALS(B2_bound, "radiative"))
   {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_ML_Gamma_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_ML_Gamma_bound < 0) handle_ML_Gamma_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_Gamma_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_ML_Gamma_bound ,ML_Gamma_bound_scalar, "SCALAR") < 0)
-        CCTK_WARN(0, "could not set SCALAR value in table!");
+   /* 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)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_B2_bound ,B2_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_Gamma_bound, 
-                      "ML_BSSN::ML_Gamma", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B2_bound, 
+                      "ML_BSSN::B2", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_Gamma!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::B2!");
   
   }
   
-  if (CCTK_EQUALS(ML_lapse_bound, "scalar"))
+  if (CCTK_EQUALS(B3_bound, "radiative"))
   {
-   /* 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)
-        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_lapse_bound, 
-                      "ML_BSSN::ML_lapse", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B3_bound, 
+                      "ML_BSSN::B3", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_lapse!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::B3!");
   
   }
   
@@ -1171,20 +1086,20 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(ML_shift_bound, "scalar"))
+  if (CCTK_EQUALS(ML_Gamma_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_Gamma_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_ML_Gamma_bound < 0) handle_ML_Gamma_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_ML_Gamma_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_ML_Gamma_bound ,ML_Gamma_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_BSSN::ML_shift", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_Gamma_bound, 
+                      "ML_BSSN::ML_Gamma", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_shift!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_Gamma!");
   
   }
   
@@ -1205,173 +1120,207 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(At11_bound, "scalar"))
+  if (CCTK_EQUALS(ML_curv_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!");
+    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_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At11_bound, 
-                      "ML_BSSN::At11", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_curv_bound, 
+                      "ML_BSSN::ML_curv", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At11!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_curv!");
   
   }
   
-  if (CCTK_EQUALS(At12_bound, "scalar"))
+  if (CCTK_EQUALS(ML_lapse_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!");
+    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_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At12_bound, 
-                      "ML_BSSN::At12", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_lapse_bound, 
+                      "ML_BSSN::ML_lapse", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At12!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_lapse!");
   
   }
   
-  if (CCTK_EQUALS(At13_bound, "scalar"))
+  if (CCTK_EQUALS(ML_dtlapse_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_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_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At13_bound, 
-                      "ML_BSSN::At13", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtlapse_bound, 
+                      "ML_BSSN::ML_dtlapse", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At13!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_dtlapse!");
   
   }
   
-  if (CCTK_EQUALS(At22_bound, "scalar"))
+  if (CCTK_EQUALS(ML_shift_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_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_shift_bound, 
+                      "ML_BSSN::ML_shift", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_shift!");
+  
+  }
+  
+  if (CCTK_EQUALS(ML_dtshift_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)
+        CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_dtshift_bound, 
+                      "ML_BSSN::ML_dtshift", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_dtshift!");
+  
+  }
+  
+  if (CCTK_EQUALS(phi_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)
       CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At22_bound, 
-                      "ML_BSSN::At22", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_phi_bound, 
+                      "ML_BSSN::phi", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At22!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::At23", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt11_bound, 
+                      "ML_BSSN::gt11", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At23!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::At33", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt12_bound, 
+                      "ML_BSSN::gt12", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At33!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::A", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt13_bound, 
+                      "ML_BSSN::gt13", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::A!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::B1", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt22_bound, 
+                      "ML_BSSN::gt22", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::B1!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::B2", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt23_bound, 
+                      "ML_BSSN::gt23", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::B2!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::B3", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt33_bound, 
+                      "ML_BSSN::gt33", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::B3!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt33!");
   
   }
   
@@ -1426,139 +1375,156 @@ extern "C" void ML_BSSN_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_BSSN::alpha", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_trK_bound, 
+                      "ML_BSSN::trK", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::alpha!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::phi", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At11_bound, 
+                      "ML_BSSN::At11", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::phi!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::gt11", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At12_bound, 
+                      "ML_BSSN::At12", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt11!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::gt12", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At13_bound, 
+                      "ML_BSSN::At13", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt12!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::gt13", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At22_bound, 
+                      "ML_BSSN::At22", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt13!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::gt22", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At23_bound, 
+                      "ML_BSSN::At23", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt22!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::gt23", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At33_bound, 
+                      "ML_BSSN::At33", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt23!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::gt33", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_alpha_bound, 
+                      "ML_BSSN::alpha", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt33!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::A", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::A!");
   
   }
   
@@ -1613,20 +1579,54 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(trK_bound, "scalar"))
+  if (CCTK_EQUALS(B1_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_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_trK_bound, 
-                      "ML_BSSN::trK", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B1_bound, 
+                      "ML_BSSN::B1", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::trK!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::B1!");
+  
+  }
+  
+  if (CCTK_EQUALS(B2_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)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_B2_bound, 
+                      "ML_BSSN::B2", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::B3", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::B3!");
   
   }
   return;
@@ -1635,50 +1635,105 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
 
 
 /* template for entries in parameter file:
+#$bound$#ML_BSSN::ML_log_confac_bound       = "skip"
+#$bound$#ML_BSSN::ML_log_confac_bound_speed = 1.0
+#$bound$#ML_BSSN::ML_log_confac_bound_limit = 0.0
+#$bound$#ML_BSSN::ML_log_confac_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::ML_metric_bound       = "skip"
+#$bound$#ML_BSSN::ML_metric_bound_speed = 1.0
+#$bound$#ML_BSSN::ML_metric_bound_limit = 0.0
+#$bound$#ML_BSSN::ML_metric_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::ML_Gamma_bound       = "skip"
+#$bound$#ML_BSSN::ML_Gamma_bound_speed = 1.0
+#$bound$#ML_BSSN::ML_Gamma_bound_limit = 0.0
+#$bound$#ML_BSSN::ML_Gamma_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::ML_trace_curv_bound       = "skip"
+#$bound$#ML_BSSN::ML_trace_curv_bound_speed = 1.0
+#$bound$#ML_BSSN::ML_trace_curv_bound_limit = 0.0
+#$bound$#ML_BSSN::ML_trace_curv_bound_scalar = 0.0
+
 #$bound$#ML_BSSN::ML_curv_bound       = "skip"
 #$bound$#ML_BSSN::ML_curv_bound_speed = 1.0
 #$bound$#ML_BSSN::ML_curv_bound_limit = 0.0
 #$bound$#ML_BSSN::ML_curv_bound_scalar = 0.0
 
+#$bound$#ML_BSSN::ML_lapse_bound       = "skip"
+#$bound$#ML_BSSN::ML_lapse_bound_speed = 1.0
+#$bound$#ML_BSSN::ML_lapse_bound_limit = 0.0
+#$bound$#ML_BSSN::ML_lapse_bound_scalar = 0.0
+
 #$bound$#ML_BSSN::ML_dtlapse_bound       = "skip"
 #$bound$#ML_BSSN::ML_dtlapse_bound_speed = 1.0
 #$bound$#ML_BSSN::ML_dtlapse_bound_limit = 0.0
 #$bound$#ML_BSSN::ML_dtlapse_bound_scalar = 0.0
 
+#$bound$#ML_BSSN::ML_shift_bound       = "skip"
+#$bound$#ML_BSSN::ML_shift_bound_speed = 1.0
+#$bound$#ML_BSSN::ML_shift_bound_limit = 0.0
+#$bound$#ML_BSSN::ML_shift_bound_scalar = 0.0
+
 #$bound$#ML_BSSN::ML_dtshift_bound       = "skip"
 #$bound$#ML_BSSN::ML_dtshift_bound_speed = 1.0
 #$bound$#ML_BSSN::ML_dtshift_bound_limit = 0.0
 #$bound$#ML_BSSN::ML_dtshift_bound_scalar = 0.0
 
-#$bound$#ML_BSSN::ML_Gamma_bound       = "skip"
-#$bound$#ML_BSSN::ML_Gamma_bound_speed = 1.0
-#$bound$#ML_BSSN::ML_Gamma_bound_limit = 0.0
-#$bound$#ML_BSSN::ML_Gamma_bound_scalar = 0.0
+#$bound$#ML_BSSN::phi_bound       = "skip"
+#$bound$#ML_BSSN::phi_bound_speed = 1.0
+#$bound$#ML_BSSN::phi_bound_limit = 0.0
+#$bound$#ML_BSSN::phi_bound_scalar = 0.0
 
-#$bound$#ML_BSSN::ML_lapse_bound       = "skip"
-#$bound$#ML_BSSN::ML_lapse_bound_speed = 1.0
-#$bound$#ML_BSSN::ML_lapse_bound_limit = 0.0
-#$bound$#ML_BSSN::ML_lapse_bound_scalar = 0.0
+#$bound$#ML_BSSN::gt11_bound       = "skip"
+#$bound$#ML_BSSN::gt11_bound_speed = 1.0
+#$bound$#ML_BSSN::gt11_bound_limit = 0.0
+#$bound$#ML_BSSN::gt11_bound_scalar = 0.0
 
-#$bound$#ML_BSSN::ML_log_confac_bound       = "skip"
-#$bound$#ML_BSSN::ML_log_confac_bound_speed = 1.0
-#$bound$#ML_BSSN::ML_log_confac_bound_limit = 0.0
-#$bound$#ML_BSSN::ML_log_confac_bound_scalar = 0.0
+#$bound$#ML_BSSN::gt12_bound       = "skip"
+#$bound$#ML_BSSN::gt12_bound_speed = 1.0
+#$bound$#ML_BSSN::gt12_bound_limit = 0.0
+#$bound$#ML_BSSN::gt12_bound_scalar = 0.0
 
-#$bound$#ML_BSSN::ML_metric_bound       = "skip"
-#$bound$#ML_BSSN::ML_metric_bound_speed = 1.0
-#$bound$#ML_BSSN::ML_metric_bound_limit = 0.0
-#$bound$#ML_BSSN::ML_metric_bound_scalar = 0.0
+#$bound$#ML_BSSN::gt13_bound       = "skip"
+#$bound$#ML_BSSN::gt13_bound_speed = 1.0
+#$bound$#ML_BSSN::gt13_bound_limit = 0.0
+#$bound$#ML_BSSN::gt13_bound_scalar = 0.0
 
-#$bound$#ML_BSSN::ML_shift_bound       = "skip"
-#$bound$#ML_BSSN::ML_shift_bound_speed = 1.0
-#$bound$#ML_BSSN::ML_shift_bound_limit = 0.0
-#$bound$#ML_BSSN::ML_shift_bound_scalar = 0.0
+#$bound$#ML_BSSN::gt22_bound       = "skip"
+#$bound$#ML_BSSN::gt22_bound_speed = 1.0
+#$bound$#ML_BSSN::gt22_bound_limit = 0.0
+#$bound$#ML_BSSN::gt22_bound_scalar = 0.0
 
-#$bound$#ML_BSSN::ML_trace_curv_bound       = "skip"
-#$bound$#ML_BSSN::ML_trace_curv_bound_speed = 1.0
-#$bound$#ML_BSSN::ML_trace_curv_bound_limit = 0.0
-#$bound$#ML_BSSN::ML_trace_curv_bound_scalar = 0.0
+#$bound$#ML_BSSN::gt23_bound       = "skip"
+#$bound$#ML_BSSN::gt23_bound_speed = 1.0
+#$bound$#ML_BSSN::gt23_bound_limit = 0.0
+#$bound$#ML_BSSN::gt23_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::gt33_bound       = "skip"
+#$bound$#ML_BSSN::gt33_bound_speed = 1.0
+#$bound$#ML_BSSN::gt33_bound_limit = 0.0
+#$bound$#ML_BSSN::gt33_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::Xt1_bound       = "skip"
+#$bound$#ML_BSSN::Xt1_bound_speed = 1.0
+#$bound$#ML_BSSN::Xt1_bound_limit = 0.0
+#$bound$#ML_BSSN::Xt1_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::Xt2_bound       = "skip"
+#$bound$#ML_BSSN::Xt2_bound_speed = 1.0
+#$bound$#ML_BSSN::Xt2_bound_limit = 0.0
+#$bound$#ML_BSSN::Xt2_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::Xt3_bound       = "skip"
+#$bound$#ML_BSSN::Xt3_bound_speed = 1.0
+#$bound$#ML_BSSN::Xt3_bound_limit = 0.0
+#$bound$#ML_BSSN::Xt3_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::trK_bound       = "skip"
+#$bound$#ML_BSSN::trK_bound_speed = 1.0
+#$bound$#ML_BSSN::trK_bound_limit = 0.0
+#$bound$#ML_BSSN::trK_bound_scalar = 0.0
 
 #$bound$#ML_BSSN::At11_bound       = "skip"
 #$bound$#ML_BSSN::At11_bound_speed = 1.0
@@ -1710,80 +1765,15 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
 #$bound$#ML_BSSN::At33_bound_limit = 0.0
 #$bound$#ML_BSSN::At33_bound_scalar = 0.0
 
-#$bound$#ML_BSSN::A_bound       = "skip"
-#$bound$#ML_BSSN::A_bound_speed = 1.0
-#$bound$#ML_BSSN::A_bound_limit = 0.0
-#$bound$#ML_BSSN::A_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::B1_bound       = "skip"
-#$bound$#ML_BSSN::B1_bound_speed = 1.0
-#$bound$#ML_BSSN::B1_bound_limit = 0.0
-#$bound$#ML_BSSN::B1_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::B2_bound       = "skip"
-#$bound$#ML_BSSN::B2_bound_speed = 1.0
-#$bound$#ML_BSSN::B2_bound_limit = 0.0
-#$bound$#ML_BSSN::B2_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::B3_bound       = "skip"
-#$bound$#ML_BSSN::B3_bound_speed = 1.0
-#$bound$#ML_BSSN::B3_bound_limit = 0.0
-#$bound$#ML_BSSN::B3_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::Xt1_bound       = "skip"
-#$bound$#ML_BSSN::Xt1_bound_speed = 1.0
-#$bound$#ML_BSSN::Xt1_bound_limit = 0.0
-#$bound$#ML_BSSN::Xt1_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::Xt2_bound       = "skip"
-#$bound$#ML_BSSN::Xt2_bound_speed = 1.0
-#$bound$#ML_BSSN::Xt2_bound_limit = 0.0
-#$bound$#ML_BSSN::Xt2_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::Xt3_bound       = "skip"
-#$bound$#ML_BSSN::Xt3_bound_speed = 1.0
-#$bound$#ML_BSSN::Xt3_bound_limit = 0.0
-#$bound$#ML_BSSN::Xt3_bound_scalar = 0.0
-
 #$bound$#ML_BSSN::alpha_bound       = "skip"
 #$bound$#ML_BSSN::alpha_bound_speed = 1.0
 #$bound$#ML_BSSN::alpha_bound_limit = 0.0
 #$bound$#ML_BSSN::alpha_bound_scalar = 0.0
 
-#$bound$#ML_BSSN::phi_bound       = "skip"
-#$bound$#ML_BSSN::phi_bound_speed = 1.0
-#$bound$#ML_BSSN::phi_bound_limit = 0.0
-#$bound$#ML_BSSN::phi_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::gt11_bound       = "skip"
-#$bound$#ML_BSSN::gt11_bound_speed = 1.0
-#$bound$#ML_BSSN::gt11_bound_limit = 0.0
-#$bound$#ML_BSSN::gt11_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::gt12_bound       = "skip"
-#$bound$#ML_BSSN::gt12_bound_speed = 1.0
-#$bound$#ML_BSSN::gt12_bound_limit = 0.0
-#$bound$#ML_BSSN::gt12_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::gt13_bound       = "skip"
-#$bound$#ML_BSSN::gt13_bound_speed = 1.0
-#$bound$#ML_BSSN::gt13_bound_limit = 0.0
-#$bound$#ML_BSSN::gt13_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::gt22_bound       = "skip"
-#$bound$#ML_BSSN::gt22_bound_speed = 1.0
-#$bound$#ML_BSSN::gt22_bound_limit = 0.0
-#$bound$#ML_BSSN::gt22_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::gt23_bound       = "skip"
-#$bound$#ML_BSSN::gt23_bound_speed = 1.0
-#$bound$#ML_BSSN::gt23_bound_limit = 0.0
-#$bound$#ML_BSSN::gt23_bound_scalar = 0.0
-
-#$bound$#ML_BSSN::gt33_bound       = "skip"
-#$bound$#ML_BSSN::gt33_bound_speed = 1.0
-#$bound$#ML_BSSN::gt33_bound_limit = 0.0
-#$bound$#ML_BSSN::gt33_bound_scalar = 0.0
+#$bound$#ML_BSSN::A_bound       = "skip"
+#$bound$#ML_BSSN::A_bound_speed = 1.0
+#$bound$#ML_BSSN::A_bound_limit = 0.0
+#$bound$#ML_BSSN::A_bound_scalar = 0.0
 
 #$bound$#ML_BSSN::beta1_bound       = "skip"
 #$bound$#ML_BSSN::beta1_bound_speed = 1.0
@@ -1800,10 +1790,20 @@ extern "C" void ML_BSSN_SelectBoundConds(CCTK_ARGUMENTS)
 #$bound$#ML_BSSN::beta3_bound_limit = 0.0
 #$bound$#ML_BSSN::beta3_bound_scalar = 0.0
 
-#$bound$#ML_BSSN::trK_bound       = "skip"
-#$bound$#ML_BSSN::trK_bound_speed = 1.0
-#$bound$#ML_BSSN::trK_bound_limit = 0.0
-#$bound$#ML_BSSN::trK_bound_scalar = 0.0
+#$bound$#ML_BSSN::B1_bound       = "skip"
+#$bound$#ML_BSSN::B1_bound_speed = 1.0
+#$bound$#ML_BSSN::B1_bound_limit = 0.0
+#$bound$#ML_BSSN::B1_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::B2_bound       = "skip"
+#$bound$#ML_BSSN::B2_bound_speed = 1.0
+#$bound$#ML_BSSN::B2_bound_limit = 0.0
+#$bound$#ML_BSSN::B2_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::B3_bound       = "skip"
+#$bound$#ML_BSSN::B3_bound_speed = 1.0
+#$bound$#ML_BSSN::B3_bound_limit = 0.0
+#$bound$#ML_BSSN::B3_bound_scalar = 0.0
 
 */
 
diff --git a/ML_BSSN/src/RegisterSymmetries.cc b/ML_BSSN/src/RegisterSymmetries.cc
index 6cdcc39..0325d23 100644
--- a/ML_BSSN/src/RegisterSymmetries.cc
+++ b/ML_BSSN/src/RegisterSymmetries.cc
@@ -19,52 +19,37 @@ extern "C" void ML_BSSN_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At11");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::phi");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt11");
   
   sym[0] = -1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At12");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt12");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At13");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt13");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At22");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt22");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At23");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At33");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt23");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::A");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::B1");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::B2");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::B3");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt33");
   
   sym[0] = -1;
   sym[1] = 1;
@@ -84,42 +69,47 @@ extern "C" void ML_BSSN_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::alpha");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::phi");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::trK");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt11");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::At11");
   
   sym[0] = -1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt12");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::At12");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt13");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::At13");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt22");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::At22");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt23");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::At23");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt33");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::At33");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::alpha");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::A");
   
   sym[0] = -1;
   sym[1] = 1;
@@ -136,54 +126,64 @@ extern "C" void ML_BSSN_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[2] = -1;
   SetCartSymVN(cctkGH, sym, "ML_BSSN::beta3");
   
-  sym[0] = 1;
+  sym[0] = -1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::trK");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::B1");
+  
+  sym[0] = 1;
+  sym[1] = -1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::B2");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = -1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::B3");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cS");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::H");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt1");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::M1");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt2");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::M2");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt3");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cA");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::M3");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::H");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::cS");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::M1");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt1");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::M2");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt2");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::M3");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt3");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::cA");
   
 }
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");
   
 }
diff --git a/ML_WaveToy/src/Boundaries.cc b/ML_WaveToy/src/Boundaries.cc
index ee5de54..c15e9af 100644
--- a/ML_WaveToy/src/Boundaries.cc
+++ b/ML_WaveToy/src/Boundaries.cc
@@ -32,17 +32,6 @@ extern "C" void ML_WaveToy_SelectBoundConds(CCTK_ARGUMENTS)
   
   CCTK_INT ierr CCTK_ATTRIBUTE_UNUSED = 0;
   
-  if (CCTK_EQUALS(WT_rho_bound, "none"  ) ||
-      CCTK_EQUALS(WT_rho_bound, "static") ||
-      CCTK_EQUALS(WT_rho_bound, "flat"  ) ||
-      CCTK_EQUALS(WT_rho_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_WaveToy::WT_rho", WT_rho_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register WT_rho_bound BC for ML_WaveToy::WT_rho!");
-  }
-  
   if (CCTK_EQUALS(WT_u_bound, "none"  ) ||
       CCTK_EQUALS(WT_u_bound, "static") ||
       CCTK_EQUALS(WT_u_bound, "flat"  ) ||
@@ -54,15 +43,15 @@ extern "C" void ML_WaveToy_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register WT_u_bound BC for ML_WaveToy::WT_u!");
   }
   
-  if (CCTK_EQUALS(rho_bound, "none"  ) ||
-      CCTK_EQUALS(rho_bound, "static") ||
-      CCTK_EQUALS(rho_bound, "flat"  ) ||
-      CCTK_EQUALS(rho_bound, "zero"  ) )
+  if (CCTK_EQUALS(WT_rho_bound, "none"  ) ||
+      CCTK_EQUALS(WT_rho_bound, "static") ||
+      CCTK_EQUALS(WT_rho_bound, "flat"  ) ||
+      CCTK_EQUALS(WT_rho_bound, "zero"  ) )
   {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_WaveToy::rho", rho_bound);
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_WaveToy::WT_rho", WT_rho_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register rho_bound BC for ML_WaveToy::rho!");
+       CCTK_WARN(0, "Failed to register WT_rho_bound BC for ML_WaveToy::WT_rho!");
   }
   
   if (CCTK_EQUALS(u_bound, "none"  ) ||
@@ -76,23 +65,15 @@ extern "C" void ML_WaveToy_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register u_bound BC for ML_WaveToy::u!");
   }
   
-  if (CCTK_EQUALS(WT_rho_bound, "radiative"))
+  if (CCTK_EQUALS(rho_bound, "none"  ) ||
+      CCTK_EQUALS(rho_bound, "static") ||
+      CCTK_EQUALS(rho_bound, "flat"  ) ||
+      CCTK_EQUALS(rho_bound, "zero"  ) )
   {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_WT_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_WT_rho_bound < 0) handle_WT_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_WT_rho_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_WT_rho_bound , WT_rho_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_WT_rho_bound ,WT_rho_bound_speed, "SPEED") < 0)
-       CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_WT_rho_bound, 
-                      "ML_WaveToy::WT_rho", "Radiation");
-  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_WaveToy::rho", rho_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_WaveToy::WT_rho!");
-  
+       CCTK_WARN(0, "Failed to register rho_bound BC for ML_WaveToy::rho!");
   }
   
   if (CCTK_EQUALS(WT_u_bound, "radiative"))
@@ -114,22 +95,22 @@ extern "C" void ML_WaveToy_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(rho_bound, "radiative"))
+  if (CCTK_EQUALS(WT_rho_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_rho_bound < 0) handle_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_rho_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_rho_bound , rho_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_WT_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_WT_rho_bound < 0) handle_WT_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_WT_rho_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_WT_rho_bound , WT_rho_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_rho_bound ,rho_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
+    if (Util_TableSetReal(handle_WT_rho_bound ,WT_rho_bound_speed, "SPEED") < 0)
+       CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_rho_bound, 
-                      "ML_WaveToy::rho", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_WT_rho_bound, 
+                      "ML_WaveToy::WT_rho", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_WaveToy::rho!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_WaveToy::WT_rho!");
   
   }
   
@@ -152,20 +133,22 @@ extern "C" void ML_WaveToy_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(WT_rho_bound, "scalar"))
+  if (CCTK_EQUALS(rho_bound, "radiative"))
   {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_WT_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_WT_rho_bound < 0) handle_WT_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_WT_rho_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_WT_rho_bound ,WT_rho_bound_scalar, "SCALAR") < 0)
-        CCTK_WARN(0, "could not set SCALAR value in table!");
+   /* select radiation boundary condition */
+    static CCTK_INT handle_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_rho_bound < 0) handle_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_rho_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_rho_bound , rho_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_rho_bound ,rho_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_WT_rho_bound, 
-                      "ML_WaveToy::WT_rho", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_rho_bound, 
+                      "ML_WaveToy::rho", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_WaveToy::WT_rho!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_WaveToy::rho!");
   
   }
   
@@ -186,20 +169,20 @@ extern "C" void ML_WaveToy_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(rho_bound, "scalar"))
+  if (CCTK_EQUALS(WT_rho_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_rho_bound < 0) handle_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_rho_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_rho_bound ,rho_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
+    static CCTK_INT handle_WT_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_WT_rho_bound < 0) handle_WT_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_WT_rho_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_WT_rho_bound ,WT_rho_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_rho_bound, 
-                      "ML_WaveToy::rho", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_WT_rho_bound, 
+                      "ML_WaveToy::WT_rho", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_WaveToy::rho!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_WaveToy::WT_rho!");
   
   }
   
@@ -219,31 +202,48 @@ extern "C" void ML_WaveToy_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Error in registering Scalar BC for ML_WaveToy::u!");
   
   }
+  
+  if (CCTK_EQUALS(rho_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_rho_bound < 0) handle_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_rho_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_rho_bound ,rho_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_rho_bound, 
+                      "ML_WaveToy::rho", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_WaveToy::rho!");
+  
+  }
   return;
 }
 
 
 
 /* template for entries in parameter file:
-#$bound$#ML_WaveToy::WT_rho_bound       = "skip"
-#$bound$#ML_WaveToy::WT_rho_bound_speed = 1.0
-#$bound$#ML_WaveToy::WT_rho_bound_limit = 0.0
-#$bound$#ML_WaveToy::WT_rho_bound_scalar = 0.0
-
 #$bound$#ML_WaveToy::WT_u_bound       = "skip"
 #$bound$#ML_WaveToy::WT_u_bound_speed = 1.0
 #$bound$#ML_WaveToy::WT_u_bound_limit = 0.0
 #$bound$#ML_WaveToy::WT_u_bound_scalar = 0.0
 
-#$bound$#ML_WaveToy::rho_bound       = "skip"
-#$bound$#ML_WaveToy::rho_bound_speed = 1.0
-#$bound$#ML_WaveToy::rho_bound_limit = 0.0
-#$bound$#ML_WaveToy::rho_bound_scalar = 0.0
+#$bound$#ML_WaveToy::WT_rho_bound       = "skip"
+#$bound$#ML_WaveToy::WT_rho_bound_speed = 1.0
+#$bound$#ML_WaveToy::WT_rho_bound_limit = 0.0
+#$bound$#ML_WaveToy::WT_rho_bound_scalar = 0.0
 
 #$bound$#ML_WaveToy::u_bound       = "skip"
 #$bound$#ML_WaveToy::u_bound_speed = 1.0
 #$bound$#ML_WaveToy::u_bound_limit = 0.0
 #$bound$#ML_WaveToy::u_bound_scalar = 0.0
 
+#$bound$#ML_WaveToy::rho_bound       = "skip"
+#$bound$#ML_WaveToy::rho_bound_speed = 1.0
+#$bound$#ML_WaveToy::rho_bound_limit = 0.0
+#$bound$#ML_WaveToy::rho_bound_scalar = 0.0
+
 */
 
diff --git a/ML_WaveToy/src/RegisterSymmetries.cc b/ML_WaveToy/src/RegisterSymmetries.cc
index 3c24883..6bf3ad0 100644
--- a/ML_WaveToy/src/RegisterSymmetries.cc
+++ b/ML_WaveToy/src/RegisterSymmetries.cc
@@ -19,12 +19,12 @@ extern "C" void ML_WaveToy_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_WaveToy::rho");
+  SetCartSymVN(cctkGH, sym, "ML_WaveToy::u");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_WaveToy::u");
+  SetCartSymVN(cctkGH, sym, "ML_WaveToy::rho");
   
   sym[0] = 1;
   sym[1] = 1;
diff --git a/ML_WaveToy_CL/src/Boundaries.cc b/ML_WaveToy_CL/src/Boundaries.cc
index 6f346a7..ddc9ddf 100644
--- a/ML_WaveToy_CL/src/Boundaries.cc
+++ b/ML_WaveToy_CL/src/Boundaries.cc
@@ -32,17 +32,6 @@ extern "C" void ML_WaveToy_CL_SelectBoundConds(CCTK_ARGUMENTS)
   
   CCTK_INT ierr CCTK_ATTRIBUTE_UNUSED = 0;
   
-  if (CCTK_EQUALS(WT_rho_bound, "none"  ) ||
-      CCTK_EQUALS(WT_rho_bound, "static") ||
-      CCTK_EQUALS(WT_rho_bound, "flat"  ) ||
-      CCTK_EQUALS(WT_rho_bound, "zero"  ) )
-  {
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_WaveToy_CL::WT_rho", WT_rho_bound);
-    if (ierr < 0)
-       CCTK_WARN(0, "Failed to register WT_rho_bound BC for ML_WaveToy_CL::WT_rho!");
-  }
-  
   if (CCTK_EQUALS(WT_u_bound, "none"  ) ||
       CCTK_EQUALS(WT_u_bound, "static") ||
       CCTK_EQUALS(WT_u_bound, "flat"  ) ||
@@ -54,15 +43,15 @@ extern "C" void ML_WaveToy_CL_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register WT_u_bound BC for ML_WaveToy_CL::WT_u!");
   }
   
-  if (CCTK_EQUALS(rho_bound, "none"  ) ||
-      CCTK_EQUALS(rho_bound, "static") ||
-      CCTK_EQUALS(rho_bound, "flat"  ) ||
-      CCTK_EQUALS(rho_bound, "zero"  ) )
+  if (CCTK_EQUALS(WT_rho_bound, "none"  ) ||
+      CCTK_EQUALS(WT_rho_bound, "static") ||
+      CCTK_EQUALS(WT_rho_bound, "flat"  ) ||
+      CCTK_EQUALS(WT_rho_bound, "zero"  ) )
   {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
-                      "ML_WaveToy_CL::rho", rho_bound);
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_WaveToy_CL::WT_rho", WT_rho_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register rho_bound BC for ML_WaveToy_CL::rho!");
+       CCTK_WARN(0, "Failed to register WT_rho_bound BC for ML_WaveToy_CL::WT_rho!");
   }
   
   if (CCTK_EQUALS(u_bound, "none"  ) ||
@@ -76,23 +65,15 @@ extern "C" void ML_WaveToy_CL_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register u_bound BC for ML_WaveToy_CL::u!");
   }
   
-  if (CCTK_EQUALS(WT_rho_bound, "radiative"))
+  if (CCTK_EQUALS(rho_bound, "none"  ) ||
+      CCTK_EQUALS(rho_bound, "static") ||
+      CCTK_EQUALS(rho_bound, "flat"  ) ||
+      CCTK_EQUALS(rho_bound, "zero"  ) )
   {
-   /* select radiation boundary condition */
-    static CCTK_INT handle_WT_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_WT_rho_bound < 0) handle_WT_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_WT_rho_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_WT_rho_bound , WT_rho_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_WT_rho_bound ,WT_rho_bound_speed, "SPEED") < 0)
-       CCTK_WARN(0, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_WT_rho_bound, 
-                      "ML_WaveToy_CL::WT_rho", "Radiation");
-  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "ML_WaveToy_CL::rho", rho_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_WaveToy_CL::WT_rho!");
-  
+       CCTK_WARN(0, "Failed to register rho_bound BC for ML_WaveToy_CL::rho!");
   }
   
   if (CCTK_EQUALS(WT_u_bound, "radiative"))
@@ -114,22 +95,22 @@ extern "C" void ML_WaveToy_CL_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(rho_bound, "radiative"))
+  if (CCTK_EQUALS(WT_rho_bound, "radiative"))
   {
    /* select radiation boundary condition */
-    static CCTK_INT handle_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_rho_bound < 0) handle_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_rho_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_rho_bound , rho_bound_limit, "LIMIT") < 0)
+    static CCTK_INT handle_WT_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_WT_rho_bound < 0) handle_WT_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_WT_rho_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_WT_rho_bound , WT_rho_bound_limit, "LIMIT") < 0)
        CCTK_WARN(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_rho_bound ,rho_bound_speed, "SPEED") < 0)
-        CCTK_WARN(0, "could not set SPEED value in table!");
+    if (Util_TableSetReal(handle_WT_rho_bound ,WT_rho_bound_speed, "SPEED") < 0)
+       CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_rho_bound, 
-                      "ML_WaveToy_CL::rho", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_WT_rho_bound, 
+                      "ML_WaveToy_CL::WT_rho", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_WaveToy_CL::rho!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_WaveToy_CL::WT_rho!");
   
   }
   
@@ -152,20 +133,22 @@ extern "C" void ML_WaveToy_CL_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(WT_rho_bound, "scalar"))
+  if (CCTK_EQUALS(rho_bound, "radiative"))
   {
-   /* select scalar boundary condition */
-    static CCTK_INT handle_WT_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_WT_rho_bound < 0) handle_WT_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_WT_rho_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_WT_rho_bound ,WT_rho_bound_scalar, "SCALAR") < 0)
-        CCTK_WARN(0, "could not set SCALAR value in table!");
+   /* select radiation boundary condition */
+    static CCTK_INT handle_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_rho_bound < 0) handle_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_rho_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_rho_bound , rho_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_rho_bound ,rho_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_WT_rho_bound, 
-                      "ML_WaveToy_CL::WT_rho", "scalar");
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_rho_bound, 
+                      "ML_WaveToy_CL::rho", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_WaveToy_CL::WT_rho!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_WaveToy_CL::rho!");
   
   }
   
@@ -186,20 +169,20 @@ extern "C" void ML_WaveToy_CL_SelectBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(rho_bound, "scalar"))
+  if (CCTK_EQUALS(WT_rho_bound, "scalar"))
   {
    /* select scalar boundary condition */
-    static CCTK_INT handle_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
-    if (handle_rho_bound < 0) handle_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_rho_bound < 0) CCTK_WARN(0, "could not create table!");
-    if (Util_TableSetReal(handle_rho_bound ,rho_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(0, "could not set SCALAR value in table!");
+    static CCTK_INT handle_WT_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_WT_rho_bound < 0) handle_WT_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_WT_rho_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_WT_rho_bound ,WT_rho_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_rho_bound, 
-                      "ML_WaveToy_CL::rho", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_WT_rho_bound, 
+                      "ML_WaveToy_CL::WT_rho", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Error in registering Scalar BC for ML_WaveToy_CL::rho!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_WaveToy_CL::WT_rho!");
   
   }
   
@@ -219,31 +202,48 @@ extern "C" void ML_WaveToy_CL_SelectBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Error in registering Scalar BC for ML_WaveToy_CL::u!");
   
   }
+  
+  if (CCTK_EQUALS(rho_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_rho_bound CCTK_ATTRIBUTE_UNUSED = -1;
+    if (handle_rho_bound < 0) handle_rho_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_rho_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_rho_bound ,rho_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_rho_bound, 
+                      "ML_WaveToy_CL::rho", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_WaveToy_CL::rho!");
+  
+  }
   return;
 }
 
 
 
 /* template for entries in parameter file:
-#$bound$#ML_WaveToy_CL::WT_rho_bound       = "skip"
-#$bound$#ML_WaveToy_CL::WT_rho_bound_speed = 1.0
-#$bound$#ML_WaveToy_CL::WT_rho_bound_limit = 0.0
-#$bound$#ML_WaveToy_CL::WT_rho_bound_scalar = 0.0
-
 #$bound$#ML_WaveToy_CL::WT_u_bound       = "skip"
 #$bound$#ML_WaveToy_CL::WT_u_bound_speed = 1.0
 #$bound$#ML_WaveToy_CL::WT_u_bound_limit = 0.0
 #$bound$#ML_WaveToy_CL::WT_u_bound_scalar = 0.0
 
-#$bound$#ML_WaveToy_CL::rho_bound       = "skip"
-#$bound$#ML_WaveToy_CL::rho_bound_speed = 1.0
-#$bound$#ML_WaveToy_CL::rho_bound_limit = 0.0
-#$bound$#ML_WaveToy_CL::rho_bound_scalar = 0.0
+#$bound$#ML_WaveToy_CL::WT_rho_bound       = "skip"
+#$bound$#ML_WaveToy_CL::WT_rho_bound_speed = 1.0
+#$bound$#ML_WaveToy_CL::WT_rho_bound_limit = 0.0
+#$bound$#ML_WaveToy_CL::WT_rho_bound_scalar = 0.0
 
 #$bound$#ML_WaveToy_CL::u_bound       = "skip"
 #$bound$#ML_WaveToy_CL::u_bound_speed = 1.0
 #$bound$#ML_WaveToy_CL::u_bound_limit = 0.0
 #$bound$#ML_WaveToy_CL::u_bound_scalar = 0.0
 
+#$bound$#ML_WaveToy_CL::rho_bound       = "skip"
+#$bound$#ML_WaveToy_CL::rho_bound_speed = 1.0
+#$bound$#ML_WaveToy_CL::rho_bound_limit = 0.0
+#$bound$#ML_WaveToy_CL::rho_bound_scalar = 0.0
+
 */
 
diff --git a/ML_WaveToy_CL/src/RegisterSymmetries.cc b/ML_WaveToy_CL/src/RegisterSymmetries.cc
index 8b918af..ea14cbb 100644
--- a/ML_WaveToy_CL/src/RegisterSymmetries.cc
+++ b/ML_WaveToy_CL/src/RegisterSymmetries.cc
@@ -19,12 +19,12 @@ extern "C" void ML_WaveToy_CL_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_WaveToy_CL::rho");
+  SetCartSymVN(cctkGH, sym, "ML_WaveToy_CL::u");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_WaveToy_CL::u");
+  SetCartSymVN(cctkGH, sym, "ML_WaveToy_CL::rho");
   
   sym[0] = 1;
   sym[1] = 1;