Re-generate all code

3 files changed, 242 insertions, 202 deletions

diff --git a/ML_ADM/src/Boundaries.c b/ML_ADM/src/Boundaries.c
index c77264d..956080a 100644
--- a/ML_ADM/src/Boundaries.c
+++ b/ML_ADM/src/Boundaries.c
@@ -43,7 +43,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::ml_curv", ml_curv_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ml_curv_bound BC for ML_ADM::ml_curv!");
+       CCTK_WARN(0, "Failed to register ml_curv_bound BC for ML_ADM::ml_curv!");
   }
   
   if (CCTK_EQUALS(ml_lapse_bound, "none"  ) ||
@@ -54,7 +54,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::ml_lapse", ml_lapse_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ml_lapse_bound BC for ML_ADM::ml_lapse!");
+       CCTK_WARN(0, "Failed to register ml_lapse_bound BC for ML_ADM::ml_lapse!");
   }
   
   if (CCTK_EQUALS(ml_metric_bound, "none"  ) ||
@@ -65,7 +65,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::ml_metric", ml_metric_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ml_metric_bound BC for ML_ADM::ml_metric!");
+       CCTK_WARN(0, "Failed to register ml_metric_bound BC for ML_ADM::ml_metric!");
   }
   
   if (CCTK_EQUALS(ml_shift_bound, "none"  ) ||
@@ -76,7 +76,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::ml_shift", ml_shift_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ml_shift_bound BC for ML_ADM::ml_shift!");
+       CCTK_WARN(0, "Failed to register ml_shift_bound BC for ML_ADM::ml_shift!");
   }
   
   if (CCTK_EQUALS(K11_bound, "none"  ) ||
@@ -87,7 +87,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::K11", K11_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K11_bound BC for ML_ADM::K11!");
+       CCTK_WARN(0, "Failed to register K11_bound BC for ML_ADM::K11!");
   }
   
   if (CCTK_EQUALS(K12_bound, "none"  ) ||
@@ -98,7 +98,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::K12", K12_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K12_bound BC for ML_ADM::K12!");
+       CCTK_WARN(0, "Failed to register K12_bound BC for ML_ADM::K12!");
   }
   
   if (CCTK_EQUALS(K13_bound, "none"  ) ||
@@ -109,7 +109,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::K13", K13_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K13_bound BC for ML_ADM::K13!");
+       CCTK_WARN(0, "Failed to register K13_bound BC for ML_ADM::K13!");
   }
   
   if (CCTK_EQUALS(K22_bound, "none"  ) ||
@@ -120,7 +120,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::K22", K22_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K22_bound BC for ML_ADM::K22!");
+       CCTK_WARN(0, "Failed to register K22_bound BC for ML_ADM::K22!");
   }
   
   if (CCTK_EQUALS(K23_bound, "none"  ) ||
@@ -131,7 +131,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::K23", K23_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K23_bound BC for ML_ADM::K23!");
+       CCTK_WARN(0, "Failed to register K23_bound BC for ML_ADM::K23!");
   }
   
   if (CCTK_EQUALS(K33_bound, "none"  ) ||
@@ -142,7 +142,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::K33", K33_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K33_bound BC for ML_ADM::K33!");
+       CCTK_WARN(0, "Failed to register K33_bound BC for ML_ADM::K33!");
   }
   
   if (CCTK_EQUALS(alpha_bound, "none"  ) ||
@@ -153,7 +153,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::alpha", alpha_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register alpha_bound BC for ML_ADM::alpha!");
+       CCTK_WARN(0, "Failed to register alpha_bound BC for ML_ADM::alpha!");
   }
   
   if (CCTK_EQUALS(g11_bound, "none"  ) ||
@@ -164,7 +164,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::g11", g11_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g11_bound BC for ML_ADM::g11!");
+       CCTK_WARN(0, "Failed to register g11_bound BC for ML_ADM::g11!");
   }
   
   if (CCTK_EQUALS(g12_bound, "none"  ) ||
@@ -175,7 +175,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::g12", g12_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g12_bound BC for ML_ADM::g12!");
+       CCTK_WARN(0, "Failed to register g12_bound BC for ML_ADM::g12!");
   }
   
   if (CCTK_EQUALS(g13_bound, "none"  ) ||
@@ -186,7 +186,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::g13", g13_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g13_bound BC for ML_ADM::g13!");
+       CCTK_WARN(0, "Failed to register g13_bound BC for ML_ADM::g13!");
   }
   
   if (CCTK_EQUALS(g22_bound, "none"  ) ||
@@ -197,7 +197,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::g22", g22_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g22_bound BC for ML_ADM::g22!");
+       CCTK_WARN(0, "Failed to register g22_bound BC for ML_ADM::g22!");
   }
   
   if (CCTK_EQUALS(g23_bound, "none"  ) ||
@@ -208,7 +208,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::g23", g23_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g23_bound BC for ML_ADM::g23!");
+       CCTK_WARN(0, "Failed to register g23_bound BC for ML_ADM::g23!");
   }
   
   if (CCTK_EQUALS(g33_bound, "none"  ) ||
@@ -219,7 +219,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::g33", g33_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g33_bound BC for ML_ADM::g33!");
+       CCTK_WARN(0, "Failed to register g33_bound BC for ML_ADM::g33!");
   }
   
   if (CCTK_EQUALS(beta1_bound, "none"  ) ||
@@ -230,7 +230,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::beta1", beta1_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register beta1_bound BC for ML_ADM::beta1!");
+       CCTK_WARN(0, "Failed to register beta1_bound BC for ML_ADM::beta1!");
   }
   
   if (CCTK_EQUALS(beta2_bound, "none"  ) ||
@@ -241,7 +241,7 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::beta2", beta2_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register beta2_bound BC for ML_ADM::beta2!");
+       CCTK_WARN(0, "Failed to register beta2_bound BC for ML_ADM::beta2!");
   }
   
   if (CCTK_EQUALS(beta3_bound, "none"  ) ||
@@ -252,686 +252,726 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_ADM::beta3", beta3_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register beta3_bound BC for ML_ADM::beta3!");
+       CCTK_WARN(0, "Failed to register beta3_bound BC for ML_ADM::beta3!");
   }
   
   if (CCTK_EQUALS(ml_curv_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_ml_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ml_curv_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ml_curv_bound = -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(-1, "could not set LIMIT value in table!");
+       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(-1, "could not set SPEED value in table!");
+       CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_curv_bound, 
                       "ML_ADM::ml_curv", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::ml_curv!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ml_curv!");
   
   }
   
   if (CCTK_EQUALS(ml_lapse_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_ml_lapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ml_lapse_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ml_lapse_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_ml_lapse_bound ,ml_lapse_bound_speed, "SPEED") < 0)
-       CCTK_WARN(-1, "could not set SPEED value in table!");
+       CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_lapse_bound, 
                       "ML_ADM::ml_lapse", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::ml_lapse!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ml_lapse!");
   
   }
   
   if (CCTK_EQUALS(ml_metric_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_ml_metric_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ml_metric_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ml_metric_bound = -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(-1, "could not set LIMIT value in table!");
+       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(-1, "could not set SPEED value in table!");
+       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(-1, "Failed to register Radiation BC for ML_ADM::ml_metric!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ml_metric!");
   
   }
   
   if (CCTK_EQUALS(ml_shift_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_ml_shift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ml_shift_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ml_shift_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_ml_shift_bound ,ml_shift_bound_speed, "SPEED") < 0)
-       CCTK_WARN(-1, "could not set SPEED value in table!");
+       CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_shift_bound, 
                       "ML_ADM::ml_shift", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::ml_shift!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ml_shift!");
   
   }
   
   if (CCTK_EQUALS(K11_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_K11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K11_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K11_bound = -1;
+    if (handle_K11_bound < 0) handle_K11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K11_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K11_bound , K11_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_K11_bound ,K11_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K11_bound, 
                       "ML_ADM::K11", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K11!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::K11!");
   
   }
   
   if (CCTK_EQUALS(K12_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_K12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K12_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K12_bound = -1;
+    if (handle_K12_bound < 0) handle_K12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K12_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K12_bound , K12_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_K12_bound ,K12_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K12_bound, 
                       "ML_ADM::K12", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K12!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::K12!");
   
   }
   
   if (CCTK_EQUALS(K13_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_K13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K13_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K13_bound = -1;
+    if (handle_K13_bound < 0) handle_K13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K13_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K13_bound , K13_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_K13_bound ,K13_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K13_bound, 
                       "ML_ADM::K13", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K13!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::K13!");
   
   }
   
   if (CCTK_EQUALS(K22_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_K22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K22_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K22_bound = -1;
+    if (handle_K22_bound < 0) handle_K22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K22_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K22_bound , K22_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_K22_bound ,K22_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K22_bound, 
                       "ML_ADM::K22", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K22!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::K22!");
   
   }
   
   if (CCTK_EQUALS(K23_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_K23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K23_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K23_bound = -1;
+    if (handle_K23_bound < 0) handle_K23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K23_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K23_bound , K23_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_K23_bound ,K23_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K23_bound, 
                       "ML_ADM::K23", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K23!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::K23!");
   
   }
   
   if (CCTK_EQUALS(K33_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_K33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K33_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K33_bound = -1;
+    if (handle_K33_bound < 0) handle_K33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K33_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K33_bound , K33_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_K33_bound ,K33_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K33_bound, 
                       "ML_ADM::K33", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K33!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::K33!");
   
   }
   
   if (CCTK_EQUALS(alpha_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_alpha_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_alpha_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_alpha_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_alpha_bound ,alpha_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_alpha_bound, 
                       "ML_ADM::alpha", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::alpha!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::alpha!");
   
   }
   
   if (CCTK_EQUALS(g11_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_g11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g11_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g11_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_g11_bound ,g11_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        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(-1, "Failed to register Radiation BC for ML_ADM::g11!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g11!");
   
   }
   
   if (CCTK_EQUALS(g12_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_g12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g12_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g12_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_g12_bound ,g12_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        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(-1, "Failed to register Radiation BC for ML_ADM::g12!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g12!");
   
   }
   
   if (CCTK_EQUALS(g13_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_g13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g13_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g13_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_g13_bound ,g13_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        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(-1, "Failed to register Radiation BC for ML_ADM::g13!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g13!");
   
   }
   
   if (CCTK_EQUALS(g22_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_g22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g22_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g22_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_g22_bound ,g22_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        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(-1, "Failed to register Radiation BC for ML_ADM::g22!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g22!");
   
   }
   
   if (CCTK_EQUALS(g23_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_g23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g23_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g23_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_g23_bound ,g23_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        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(-1, "Failed to register Radiation BC for ML_ADM::g23!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g23!");
   
   }
   
   if (CCTK_EQUALS(g33_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_g33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g33_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g33_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_g33_bound ,g33_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        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(-1, "Failed to register Radiation BC for ML_ADM::g33!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::g33!");
   
   }
   
   if (CCTK_EQUALS(beta1_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_beta1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_beta1_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_beta1_bound = -1;
+    if (handle_beta1_bound < 0) handle_beta1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_beta1_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_beta1_bound , beta1_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_beta1_bound ,beta1_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta1_bound, 
                       "ML_ADM::beta1", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::beta1!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::beta1!");
   
   }
   
   if (CCTK_EQUALS(beta2_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_beta2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_beta2_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_beta2_bound = -1;
+    if (handle_beta2_bound < 0) handle_beta2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_beta2_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_beta2_bound , beta2_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_beta2_bound ,beta2_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta2_bound, 
                       "ML_ADM::beta2", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::beta2!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::beta2!");
   
   }
   
   if (CCTK_EQUALS(beta3_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_beta3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_beta3_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_beta3_bound = -1;
+    if (handle_beta3_bound < 0) handle_beta3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_beta3_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_beta3_bound , beta3_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_beta3_bound ,beta3_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
+        CCTK_WARN(0, "could not set SPEED value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta3_bound, 
                       "ML_ADM::beta3", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::beta3!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::beta3!");
   
   }
   
   if (CCTK_EQUALS(ml_curv_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_ml_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ml_curv_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ml_curv_bound = -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(-1, "could not set SCALAR value in table!");
+        CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_curv_bound, 
                       "ML_ADM::ml_curv", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_ADM::ml_curv!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ml_curv!");
   
   }
   
   if (CCTK_EQUALS(ml_lapse_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_ml_lapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ml_lapse_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ml_lapse_bound = -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(-1, "could not set SCALAR value in table!");
+        CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_lapse_bound, 
                       "ML_ADM::ml_lapse", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_ADM::ml_lapse!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ml_lapse!");
   
   }
   
   if (CCTK_EQUALS(ml_metric_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_ml_metric_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ml_metric_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ml_metric_bound = -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(-1, "could not set SCALAR value in table!");
+        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(-1, "Failed to register Scalar BC for ML_ADM::ml_metric!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ml_metric!");
   
   }
   
   if (CCTK_EQUALS(ml_shift_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_ml_shift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ml_shift_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ml_shift_bound = -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(-1, "could not set SCALAR value in table!");
+        CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_shift_bound, 
                       "ML_ADM::ml_shift", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_ADM::ml_shift!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ml_shift!");
   
   }
   
   if (CCTK_EQUALS(K11_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_K11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K11_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K11_bound = -1;
+    if (handle_K11_bound < 0) handle_K11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K11_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K11_bound ,K11_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
+      CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K11_bound, 
                       "ML_ADM::K11", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K11!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::K11!");
   
   }
   
   if (CCTK_EQUALS(K12_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_K12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K12_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K12_bound = -1;
+    if (handle_K12_bound < 0) handle_K12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K12_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K12_bound ,K12_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
+      CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K12_bound, 
                       "ML_ADM::K12", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K12!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::K12!");
   
   }
   
   if (CCTK_EQUALS(K13_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_K13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K13_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K13_bound = -1;
+    if (handle_K13_bound < 0) handle_K13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K13_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K13_bound ,K13_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
+      CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K13_bound, 
                       "ML_ADM::K13", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K13!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::K13!");
   
   }
   
   if (CCTK_EQUALS(K22_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_K22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K22_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K22_bound = -1;
+    if (handle_K22_bound < 0) handle_K22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K22_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K22_bound ,K22_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
+      CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K22_bound, 
                       "ML_ADM::K22", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K22!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::K22!");
   
   }
   
   if (CCTK_EQUALS(K23_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_K23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K23_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K23_bound = -1;
+    if (handle_K23_bound < 0) handle_K23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K23_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K23_bound ,K23_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
+      CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K23_bound, 
                       "ML_ADM::K23", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K23!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::K23!");
   
   }
   
   if (CCTK_EQUALS(K33_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_K33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K33_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_K33_bound = -1;
+    if (handle_K33_bound < 0) handle_K33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_K33_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_K33_bound ,K33_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
+      CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K33_bound, 
                       "ML_ADM::K33", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K33!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::K33!");
   
   }
   
   if (CCTK_EQUALS(alpha_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_alpha_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_alpha_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_alpha_bound = -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(-1, "could not set SCALAR value in table!");
+      CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_alpha_bound, 
                       "ML_ADM::alpha", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::alpha!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::alpha!");
   
   }
   
   if (CCTK_EQUALS(g11_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_g11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g11_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g11_bound = -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(-1, "could not set SCALAR value in table!");
+      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(-1, "Error in registering Scalar BC for ML_ADM::g11!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g11!");
   
   }
   
   if (CCTK_EQUALS(g12_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_g12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g12_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g12_bound = -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(-1, "could not set SCALAR value in table!");
+      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(-1, "Error in registering Scalar BC for ML_ADM::g12!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g12!");
   
   }
   
   if (CCTK_EQUALS(g13_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_g13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g13_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g13_bound = -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(-1, "could not set SCALAR value in table!");
+      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(-1, "Error in registering Scalar BC for ML_ADM::g13!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g13!");
   
   }
   
   if (CCTK_EQUALS(g22_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_g22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g22_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g22_bound = -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(-1, "could not set SCALAR value in table!");
+      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(-1, "Error in registering Scalar BC for ML_ADM::g22!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g22!");
   
   }
   
   if (CCTK_EQUALS(g23_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_g23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g23_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g23_bound = -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(-1, "could not set SCALAR value in table!");
+      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(-1, "Error in registering Scalar BC for ML_ADM::g23!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g23!");
   
   }
   
   if (CCTK_EQUALS(g33_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_g33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g33_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_g33_bound = -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(-1, "could not set SCALAR value in table!");
+      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(-1, "Error in registering Scalar BC for ML_ADM::g33!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::g33!");
   
   }
   
   if (CCTK_EQUALS(beta1_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_beta1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_beta1_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_beta1_bound = -1;
+    if (handle_beta1_bound < 0) handle_beta1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_beta1_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_beta1_bound ,beta1_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
+      CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta1_bound, 
                       "ML_ADM::beta1", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::beta1!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::beta1!");
   
   }
   
   if (CCTK_EQUALS(beta2_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_beta2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_beta2_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_beta2_bound = -1;
+    if (handle_beta2_bound < 0) handle_beta2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_beta2_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_beta2_bound ,beta2_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
+      CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta2_bound, 
                       "ML_ADM::beta2", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::beta2!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::beta2!");
   
   }
   
   if (CCTK_EQUALS(beta3_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_beta3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_beta3_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_beta3_bound = -1;
+    if (handle_beta3_bound < 0) handle_beta3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_beta3_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_beta3_bound ,beta3_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
+      CCTK_WARN(0, "could not set SCALAR value in table!");
   
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta3_bound, 
                       "ML_ADM::beta3", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::beta3!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_ADM::beta3!");
   
   }
   return;
diff --git a/ML_ADM/src/ML_ADM_boundary.c b/ML_ADM/src/ML_ADM_boundary.c
index 02c77aa..f4f0289 100644
--- a/ML_ADM/src/ML_ADM_boundary.c
+++ b/ML_ADM/src/ML_ADM_boundary.c
@@ -177,5 +177,5 @@ void ML_ADM_boundary(CCTK_ARGUMENTS)
   DECLARE_CCTK_ARGUMENTS
   DECLARE_CCTK_PARAMETERS
   
-  GenericFD_LoopOverBoundary(cctkGH, &ML_ADM_boundary_Body);
+  GenericFD_LoopOverBoundaryWithGhosts(cctkGH, &ML_ADM_boundary_Body);
 }
diff --git a/ML_ADM/src/ML_ADM_constraints_boundary.c b/ML_ADM/src/ML_ADM_constraints_boundary.c
index 7a7053d..ae07d3b 100644
--- a/ML_ADM/src/ML_ADM_constraints_boundary.c
+++ b/ML_ADM/src/ML_ADM_constraints_boundary.c
@@ -139,5 +139,5 @@ void ML_ADM_constraints_boundary(CCTK_ARGUMENTS)
   DECLARE_CCTK_ARGUMENTS
   DECLARE_CCTK_PARAMETERS
   
-  GenericFD_LoopOverBoundary(cctkGH, &ML_ADM_constraints_boundary_Body);
+  GenericFD_LoopOverBoundaryWithGhosts(cctkGH, &ML_ADM_constraints_boundary_Body);
 }