Merge commit 'origin/master'

7 files changed, 422 insertions, 347 deletions

diff --git a/ML_BSSN/interface.ccl b/ML_BSSN/interface.ccl
index ea46ba0..9e38ee0 100644
--- a/ML_BSSN/interface.ccl
+++ b/ML_BSSN/interface.ccl
@@ -9,9 +9,7 @@ inherits:   ADMBase TmunuBase Grid GenericFD Boundary
 
 
 
-USES INCLUDE: GenericFD.h
-USES INCLUDE: Symmetry.h
-USES INCLUDE: sbp_calc_coeffs.h
+USES INCLUDE: GenericFD.hSymmetry.hsbp_calc_coeffs.h
 USES INCLUDE: Boundary.h
 USES INCLUDE: loopcontrol.h
 
diff --git a/ML_BSSN/param.ccl b/ML_BSSN/param.ccl
index 03987c4..89c654a 100644
--- a/ML_BSSN/param.ccl
+++ b/ML_BSSN/param.ccl
@@ -120,7 +120,7 @@ CCTK_INT ML_BSSN_MaxNumConstrainedVars "Number of constrained variables used by
   43:43 :: "Number of constrained variables used by this thorn"
 } 43
 
-private:
+restricted:
 CCTK_INT timelevels "Number of active timelevels"
 {
   0:3 :: ""
diff --git a/ML_BSSN/schedule.ccl b/ML_BSSN/schedule.ccl
index 997deca..ac085cd 100644
--- a/ML_BSSN/schedule.ccl
+++ b/ML_BSSN/schedule.ccl
@@ -223,6 +223,15 @@ if (CCTK_EQUALS(evolution_method, "ML_BSSN"))
 
 if (CCTK_EQUALS(my_boundary_condition, "Minkowski"))
 {
+  schedule ML_BSSN_boundary AT initial AFTER ML_BSSN_convertFromADMBaseGamma
+  {
+    LANG: C
+  } "ML_BSSN_boundary"
+}
+
+
+if (CCTK_EQUALS(my_boundary_condition, "Minkowski"))
+{
   schedule ML_BSSN_boundary IN MoL_PostStep
   {
     LANG: C
diff --git a/ML_BSSN/src/Boundaries.c b/ML_BSSN/src/Boundaries.c
index 4220352..3d91f94 100644
--- a/ML_BSSN/src/Boundaries.c
+++ b/ML_BSSN/src/Boundaries.c
@@ -43,7 +43,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::ML_curv", ML_curv_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ML_curv_bound BC for ML_BSSN::ML_curv!");
+       CCTK_WARN(0, "Failed to register ML_curv_bound BC for ML_BSSN::ML_curv!");
   }
   
   if (CCTK_EQUALS(ML_dtlapse_bound, "none"  ) ||
@@ -54,7 +54,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::ML_dtlapse", ML_dtlapse_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ML_dtlapse_bound BC for ML_BSSN::ML_dtlapse!");
+       CCTK_WARN(0, "Failed to register ML_dtlapse_bound BC for ML_BSSN::ML_dtlapse!");
   }
   
   if (CCTK_EQUALS(ML_dtshift_bound, "none"  ) ||
@@ -65,7 +65,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::ML_dtshift", ML_dtshift_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ML_dtshift_bound BC for ML_BSSN::ML_dtshift!");
+       CCTK_WARN(0, "Failed to register ML_dtshift_bound BC for ML_BSSN::ML_dtshift!");
   }
   
   if (CCTK_EQUALS(ML_Gamma_bound, "none"  ) ||
@@ -76,7 +76,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::ML_Gamma", ML_Gamma_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ML_Gamma_bound BC for ML_BSSN::ML_Gamma!");
+       CCTK_WARN(0, "Failed to register ML_Gamma_bound BC for ML_BSSN::ML_Gamma!");
   }
   
   if (CCTK_EQUALS(ML_lapse_bound, "none"  ) ||
@@ -87,7 +87,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::ML_lapse", ML_lapse_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ML_lapse_bound BC for ML_BSSN::ML_lapse!");
+       CCTK_WARN(0, "Failed to register ML_lapse_bound BC for ML_BSSN::ML_lapse!");
   }
   
   if (CCTK_EQUALS(ML_log_confac_bound, "none"  ) ||
@@ -98,7 +98,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::ML_log_confac", ML_log_confac_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ML_log_confac_bound BC for ML_BSSN::ML_log_confac!");
+       CCTK_WARN(0, "Failed to register ML_log_confac_bound BC for ML_BSSN::ML_log_confac!");
   }
   
   if (CCTK_EQUALS(ML_metric_bound, "none"  ) ||
@@ -109,7 +109,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::ML_metric", ML_metric_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ML_metric_bound BC for ML_BSSN::ML_metric!");
+       CCTK_WARN(0, "Failed to register ML_metric_bound BC for ML_BSSN::ML_metric!");
   }
   
   if (CCTK_EQUALS(ML_shift_bound, "none"  ) ||
@@ -120,7 +120,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::ML_shift", ML_shift_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ML_shift_bound BC for ML_BSSN::ML_shift!");
+       CCTK_WARN(0, "Failed to register ML_shift_bound BC for ML_BSSN::ML_shift!");
   }
   
   if (CCTK_EQUALS(ML_trace_curv_bound, "none"  ) ||
@@ -131,7 +131,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::ML_trace_curv", ML_trace_curv_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register ML_trace_curv_bound BC for ML_BSSN::ML_trace_curv!");
+       CCTK_WARN(0, "Failed to register ML_trace_curv_bound BC for ML_BSSN::ML_trace_curv!");
   }
   
   if (CCTK_EQUALS(At11_bound, "none"  ) ||
@@ -142,7 +142,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::At11", At11_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register At11_bound BC for ML_BSSN::At11!");
+       CCTK_WARN(0, "Failed to register At11_bound BC for ML_BSSN::At11!");
   }
   
   if (CCTK_EQUALS(At12_bound, "none"  ) ||
@@ -153,7 +153,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::At12", At12_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register At12_bound BC for ML_BSSN::At12!");
+       CCTK_WARN(0, "Failed to register At12_bound BC for ML_BSSN::At12!");
   }
   
   if (CCTK_EQUALS(At13_bound, "none"  ) ||
@@ -164,7 +164,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::At13", At13_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register At13_bound BC for ML_BSSN::At13!");
+       CCTK_WARN(0, "Failed to register At13_bound BC for ML_BSSN::At13!");
   }
   
   if (CCTK_EQUALS(At22_bound, "none"  ) ||
@@ -175,7 +175,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::At22", At22_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register At22_bound BC for ML_BSSN::At22!");
+       CCTK_WARN(0, "Failed to register At22_bound BC for ML_BSSN::At22!");
   }
   
   if (CCTK_EQUALS(At23_bound, "none"  ) ||
@@ -186,7 +186,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::At23", At23_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register At23_bound BC for ML_BSSN::At23!");
+       CCTK_WARN(0, "Failed to register At23_bound BC for ML_BSSN::At23!");
   }
   
   if (CCTK_EQUALS(At33_bound, "none"  ) ||
@@ -197,7 +197,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::At33", At33_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register At33_bound BC for ML_BSSN::At33!");
+       CCTK_WARN(0, "Failed to register At33_bound BC for ML_BSSN::At33!");
   }
   
   if (CCTK_EQUALS(A_bound, "none"  ) ||
@@ -208,7 +208,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::A", A_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register A_bound BC for ML_BSSN::A!");
+       CCTK_WARN(0, "Failed to register A_bound BC for ML_BSSN::A!");
   }
   
   if (CCTK_EQUALS(B1_bound, "none"  ) ||
@@ -219,7 +219,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::B1", B1_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register B1_bound BC for ML_BSSN::B1!");
+       CCTK_WARN(0, "Failed to register B1_bound BC for ML_BSSN::B1!");
   }
   
   if (CCTK_EQUALS(B2_bound, "none"  ) ||
@@ -230,7 +230,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::B2", B2_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register B2_bound BC for ML_BSSN::B2!");
+       CCTK_WARN(0, "Failed to register B2_bound BC for ML_BSSN::B2!");
   }
   
   if (CCTK_EQUALS(B3_bound, "none"  ) ||
@@ -241,7 +241,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::B3", B3_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register B3_bound BC for ML_BSSN::B3!");
+       CCTK_WARN(0, "Failed to register B3_bound BC for ML_BSSN::B3!");
   }
   
   if (CCTK_EQUALS(Xt1_bound, "none"  ) ||
@@ -252,7 +252,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::Xt1", Xt1_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Xt1_bound BC for ML_BSSN::Xt1!");
+       CCTK_WARN(0, "Failed to register Xt1_bound BC for ML_BSSN::Xt1!");
   }
   
   if (CCTK_EQUALS(Xt2_bound, "none"  ) ||
@@ -263,7 +263,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::Xt2", Xt2_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Xt2_bound BC for ML_BSSN::Xt2!");
+       CCTK_WARN(0, "Failed to register Xt2_bound BC for ML_BSSN::Xt2!");
   }
   
   if (CCTK_EQUALS(Xt3_bound, "none"  ) ||
@@ -274,7 +274,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::Xt3", Xt3_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Xt3_bound BC for ML_BSSN::Xt3!");
+       CCTK_WARN(0, "Failed to register Xt3_bound BC for ML_BSSN::Xt3!");
   }
   
   if (CCTK_EQUALS(alpha_bound, "none"  ) ||
@@ -285,7 +285,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::alpha", alpha_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register alpha_bound BC for ML_BSSN::alpha!");
+       CCTK_WARN(0, "Failed to register alpha_bound BC for ML_BSSN::alpha!");
   }
   
   if (CCTK_EQUALS(phi_bound, "none"  ) ||
@@ -296,7 +296,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::phi", phi_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register phi_bound BC for ML_BSSN::phi!");
+       CCTK_WARN(0, "Failed to register phi_bound BC for ML_BSSN::phi!");
   }
   
   if (CCTK_EQUALS(gt11_bound, "none"  ) ||
@@ -307,7 +307,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::gt11", gt11_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register gt11_bound BC for ML_BSSN::gt11!");
+       CCTK_WARN(0, "Failed to register gt11_bound BC for ML_BSSN::gt11!");
   }
   
   if (CCTK_EQUALS(gt12_bound, "none"  ) ||
@@ -318,7 +318,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::gt12", gt12_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register gt12_bound BC for ML_BSSN::gt12!");
+       CCTK_WARN(0, "Failed to register gt12_bound BC for ML_BSSN::gt12!");
   }
   
   if (CCTK_EQUALS(gt13_bound, "none"  ) ||
@@ -329,7 +329,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::gt13", gt13_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register gt13_bound BC for ML_BSSN::gt13!");
+       CCTK_WARN(0, "Failed to register gt13_bound BC for ML_BSSN::gt13!");
   }
   
   if (CCTK_EQUALS(gt22_bound, "none"  ) ||
@@ -340,7 +340,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::gt22", gt22_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register gt22_bound BC for ML_BSSN::gt22!");
+       CCTK_WARN(0, "Failed to register gt22_bound BC for ML_BSSN::gt22!");
   }
   
   if (CCTK_EQUALS(gt23_bound, "none"  ) ||
@@ -351,7 +351,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::gt23", gt23_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register gt23_bound BC for ML_BSSN::gt23!");
+       CCTK_WARN(0, "Failed to register gt23_bound BC for ML_BSSN::gt23!");
   }
   
   if (CCTK_EQUALS(gt33_bound, "none"  ) ||
@@ -362,7 +362,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::gt33", gt33_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register gt33_bound BC for ML_BSSN::gt33!");
+       CCTK_WARN(0, "Failed to register gt33_bound BC for ML_BSSN::gt33!");
   }
   
   if (CCTK_EQUALS(beta1_bound, "none"  ) ||
@@ -373,7 +373,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::beta1", beta1_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register beta1_bound BC for ML_BSSN::beta1!");
+       CCTK_WARN(0, "Failed to register beta1_bound BC for ML_BSSN::beta1!");
   }
   
   if (CCTK_EQUALS(beta2_bound, "none"  ) ||
@@ -384,7 +384,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::beta2", beta2_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register beta2_bound BC for ML_BSSN::beta2!");
+       CCTK_WARN(0, "Failed to register beta2_bound BC for ML_BSSN::beta2!");
   }
   
   if (CCTK_EQUALS(beta3_bound, "none"  ) ||
@@ -395,7 +395,7 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::beta3", beta3_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register beta3_bound BC for ML_BSSN::beta3!");
+       CCTK_WARN(0, "Failed to register beta3_bound BC for ML_BSSN::beta3!");
   }
   
   if (CCTK_EQUALS(trK_bound, "none"  ) ||
@@ -406,1162 +406,1230 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
     ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
                       "ML_BSSN::trK", trK_bound);
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register trK_bound BC for ML_BSSN::trK!");
+       CCTK_WARN(0, "Failed to register trK_bound BC for ML_BSSN::trK!");
   }
   
   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_BSSN::ML_curv", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::ML_curv!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_curv!");
   
   }
   
   if (CCTK_EQUALS(ML_dtlapse_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_ML_dtlapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_dtlapse_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ML_dtlapse_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_ML_dtlapse_bound ,ML_dtlapse_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_dtlapse_bound, 
                       "ML_BSSN::ML_dtlapse", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::ML_dtlapse!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_dtlapse!");
   
   }
   
   if (CCTK_EQUALS(ML_dtshift_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_ML_dtshift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_dtshift_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ML_dtshift_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_ML_dtshift_bound ,ML_dtshift_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_dtshift_bound, 
                       "ML_BSSN::ML_dtshift", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::ML_dtshift!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_dtshift!");
   
   }
   
   if (CCTK_EQUALS(ML_Gamma_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_ML_Gamma_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_Gamma_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ML_Gamma_bound = -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_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_Gamma_bound ,ML_Gamma_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_Gamma_bound, 
                       "ML_BSSN::ML_Gamma", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::ML_Gamma!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_Gamma!");
   
   }
   
   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_BSSN::ML_lapse", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::ML_lapse!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_lapse!");
   
   }
   
   if (CCTK_EQUALS(ML_log_confac_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_ML_log_confac_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_log_confac_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ML_log_confac_bound = -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(-1, "could not set LIMIT value in table!");
+       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)
-       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_log_confac_bound, 
                       "ML_BSSN::ML_log_confac", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::ML_log_confac!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_log_confac!");
   
   }
   
   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_BSSN::ML_metric", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::ML_metric!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::ML_shift", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::ML_shift!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_shift!");
   
   }
   
   if (CCTK_EQUALS(ML_trace_curv_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_ML_trace_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_trace_curv_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ML_trace_curv_bound = -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(-1, "could not set LIMIT value in table!");
+       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)
-       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_trace_curv_bound, 
                       "ML_BSSN::ML_trace_curv", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::ML_trace_curv!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::ML_trace_curv!");
   
   }
   
   if (CCTK_EQUALS(At11_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_At11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At11_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At11_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_At11_bound ,At11_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_At11_bound, 
                       "ML_BSSN::At11", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::At11!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At11!");
   
   }
   
   if (CCTK_EQUALS(At12_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_At12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At12_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At12_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_At12_bound ,At12_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_At12_bound, 
                       "ML_BSSN::At12", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::At12!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At12!");
   
   }
   
   if (CCTK_EQUALS(At13_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_At13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At13_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At13_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_At13_bound ,At13_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_At13_bound, 
                       "ML_BSSN::At13", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::At13!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At13!");
   
   }
   
   if (CCTK_EQUALS(At22_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_At22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At22_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At22_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_At22_bound ,At22_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_At22_bound, 
                       "ML_BSSN::At22", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::At22!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At22!");
   
   }
   
   if (CCTK_EQUALS(At23_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_At23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At23_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At23_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_At23_bound ,At23_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_At23_bound, 
                       "ML_BSSN::At23", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::At23!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At23!");
   
   }
   
   if (CCTK_EQUALS(At33_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_At33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At33_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At33_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_At33_bound ,At33_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_At33_bound, 
                       "ML_BSSN::At33", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::At33!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::At33!");
   
   }
   
   if (CCTK_EQUALS(A_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_A_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_A_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_A_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_A_bound ,A_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_A_bound, 
                       "ML_BSSN::A", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::A!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::A!");
   
   }
   
   if (CCTK_EQUALS(B1_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_B1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B1_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_B1_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_B1_bound ,B1_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_B1_bound, 
                       "ML_BSSN::B1", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::B1!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::B1!");
   
   }
   
   if (CCTK_EQUALS(B2_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_B2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B2_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_B2_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_B2_bound ,B2_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_B2_bound, 
                       "ML_BSSN::B2", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::B2!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::B2!");
   
   }
   
   if (CCTK_EQUALS(B3_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_B3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B3_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_B3_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_B3_bound ,B3_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_B3_bound, 
                       "ML_BSSN::B3", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::B3!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::B3!");
   
   }
   
   if (CCTK_EQUALS(Xt1_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_Xt1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_Xt1_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_Xt1_bound = -1;
+    if (handle_Xt1_bound < 0) handle_Xt1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_Xt1_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_Xt1_bound , Xt1_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_Xt1_bound ,Xt1_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_Xt1_bound, 
                       "ML_BSSN::Xt1", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::Xt1!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::Xt1!");
   
   }
   
   if (CCTK_EQUALS(Xt2_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_Xt2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_Xt2_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_Xt2_bound = -1;
+    if (handle_Xt2_bound < 0) handle_Xt2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_Xt2_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_Xt2_bound , Xt2_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_Xt2_bound ,Xt2_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_Xt2_bound, 
                       "ML_BSSN::Xt2", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::Xt2!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::Xt2!");
   
   }
   
   if (CCTK_EQUALS(Xt3_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_Xt3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_Xt3_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_Xt3_bound = -1;
+    if (handle_Xt3_bound < 0) handle_Xt3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_Xt3_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_Xt3_bound , Xt3_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_Xt3_bound ,Xt3_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_Xt3_bound, 
                       "ML_BSSN::Xt3", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::Xt3!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::Xt3!");
   
   }
   
   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_BSSN::alpha", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::alpha!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::alpha!");
   
   }
   
   if (CCTK_EQUALS(phi_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_phi_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_phi_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_phi_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_phi_bound ,phi_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_phi_bound, 
                       "ML_BSSN::phi", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::phi!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::phi!");
   
   }
   
   if (CCTK_EQUALS(gt11_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_gt11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt11_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt11_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_gt11_bound ,gt11_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_gt11_bound, 
                       "ML_BSSN::gt11", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::gt11!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt11!");
   
   }
   
   if (CCTK_EQUALS(gt12_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_gt12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt12_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt12_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_gt12_bound ,gt12_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_gt12_bound, 
                       "ML_BSSN::gt12", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::gt12!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt12!");
   
   }
   
   if (CCTK_EQUALS(gt13_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_gt13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt13_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt13_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_gt13_bound ,gt13_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_gt13_bound, 
                       "ML_BSSN::gt13", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::gt13!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt13!");
   
   }
   
   if (CCTK_EQUALS(gt22_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_gt22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt22_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt22_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_gt22_bound ,gt22_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_gt22_bound, 
                       "ML_BSSN::gt22", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::gt22!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt22!");
   
   }
   
   if (CCTK_EQUALS(gt23_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_gt23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt23_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt23_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_gt23_bound ,gt23_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_gt23_bound, 
                       "ML_BSSN::gt23", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::gt23!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt23!");
   
   }
   
   if (CCTK_EQUALS(gt33_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_gt33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt33_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt33_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_gt33_bound ,gt33_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_gt33_bound, 
                       "ML_BSSN::gt33", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::gt33!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::gt33!");
   
   }
   
   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_BSSN::beta1", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::beta1!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::beta2", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::beta2!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::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_BSSN::beta3", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::beta3!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::beta3!");
   
   }
   
   if (CCTK_EQUALS(trK_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    CCTK_INT handle_trK_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_trK_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_trK_bound = -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(-1, "could not set LIMIT value in table!");
+       CCTK_WARN(0, "could not set LIMIT value in table!");
     if (Util_TableSetReal(handle_trK_bound ,trK_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_trK_bound, 
                       "ML_BSSN::trK", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::trK!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_BSSN::trK!");
   
   }
   
   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_BSSN::ML_curv", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::ML_curv!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_curv!");
   
   }
   
   if (CCTK_EQUALS(ML_dtlapse_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_ML_dtlapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_dtlapse_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ML_dtlapse_bound = -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(-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_dtlapse_bound, 
                       "ML_BSSN::ML_dtlapse", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::ML_dtlapse!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_dtlapse!");
   
   }
   
   if (CCTK_EQUALS(ML_dtshift_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_ML_dtshift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_dtshift_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ML_dtshift_bound = -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(-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_dtshift_bound, 
                       "ML_BSSN::ML_dtshift", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::ML_dtshift!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_dtshift!");
   
   }
   
   if (CCTK_EQUALS(ML_Gamma_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_ML_Gamma_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_Gamma_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ML_Gamma_bound = -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(-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_Gamma_bound, 
                       "ML_BSSN::ML_Gamma", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::ML_Gamma!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_Gamma!");
   
   }
   
   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_BSSN::ML_lapse", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::ML_lapse!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_lapse!");
   
   }
   
   if (CCTK_EQUALS(ML_log_confac_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_ML_log_confac_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_log_confac_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ML_log_confac_bound = -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(-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_log_confac_bound, 
                       "ML_BSSN::ML_log_confac", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::ML_log_confac!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_log_confac!");
   
   }
   
   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_BSSN::ML_metric", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::ML_metric!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::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_BSSN::ML_shift", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::ML_shift!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_shift!");
   
   }
   
   if (CCTK_EQUALS(ML_trace_curv_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_ML_trace_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_ML_trace_curv_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_ML_trace_curv_bound = -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(-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_trace_curv_bound, 
                       "ML_BSSN::ML_trace_curv", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::ML_trace_curv!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_BSSN::ML_trace_curv!");
   
   }
   
   if (CCTK_EQUALS(At11_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_At11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At11_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At11_bound = -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(-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_At11_bound, 
                       "ML_BSSN::At11", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::At11!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At11!");
   
   }
   
   if (CCTK_EQUALS(At12_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_At12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At12_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At12_bound = -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(-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_At12_bound, 
                       "ML_BSSN::At12", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::At12!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At12!");
   
   }
   
   if (CCTK_EQUALS(At13_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_At13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At13_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At13_bound = -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(-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_At13_bound, 
                       "ML_BSSN::At13", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::At13!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At13!");
   
   }
   
   if (CCTK_EQUALS(At22_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_At22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At22_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At22_bound = -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(-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_At22_bound, 
                       "ML_BSSN::At22", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::At22!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At22!");
   
   }
   
   if (CCTK_EQUALS(At23_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_At23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At23_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At23_bound = -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(-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_At23_bound, 
                       "ML_BSSN::At23", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::At23!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At23!");
   
   }
   
   if (CCTK_EQUALS(At33_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_At33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_At33_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_At33_bound = -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(-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_At33_bound, 
                       "ML_BSSN::At33", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::At33!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::At33!");
   
   }
   
   if (CCTK_EQUALS(A_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_A_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_A_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_A_bound = -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(-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_A_bound, 
                       "ML_BSSN::A", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::A!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::A!");
   
   }
   
   if (CCTK_EQUALS(B1_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_B1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B1_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_B1_bound = -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(-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_B1_bound, 
                       "ML_BSSN::B1", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::B1!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::B1!");
   
   }
   
   if (CCTK_EQUALS(B2_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_B2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B2_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_B2_bound = -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(-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_B2_bound, 
                       "ML_BSSN::B2", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::B2!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::B2!");
   
   }
   
   if (CCTK_EQUALS(B3_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_B3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_B3_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_B3_bound = -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(-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_B3_bound, 
                       "ML_BSSN::B3", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::B3!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::B3!");
   
   }
   
   if (CCTK_EQUALS(Xt1_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_Xt1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_Xt1_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_Xt1_bound = -1;
+    if (handle_Xt1_bound < 0) handle_Xt1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_Xt1_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_Xt1_bound ,Xt1_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_Xt1_bound, 
                       "ML_BSSN::Xt1", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::Xt1!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::Xt1!");
   
   }
   
   if (CCTK_EQUALS(Xt2_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_Xt2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_Xt2_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_Xt2_bound = -1;
+    if (handle_Xt2_bound < 0) handle_Xt2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_Xt2_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_Xt2_bound ,Xt2_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_Xt2_bound, 
                       "ML_BSSN::Xt2", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::Xt2!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::Xt2!");
   
   }
   
   if (CCTK_EQUALS(Xt3_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_Xt3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_Xt3_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_Xt3_bound = -1;
+    if (handle_Xt3_bound < 0) handle_Xt3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_Xt3_bound < 0) CCTK_WARN(0, "could not create table!");
     if (Util_TableSetReal(handle_Xt3_bound ,Xt3_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_Xt3_bound, 
                       "ML_BSSN::Xt3", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::Xt3!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::Xt3!");
   
   }
   
   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_BSSN::alpha", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::alpha!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::alpha!");
   
   }
   
   if (CCTK_EQUALS(phi_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_phi_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_phi_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_phi_bound = -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(-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_phi_bound, 
                       "ML_BSSN::phi", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::phi!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::phi!");
   
   }
   
   if (CCTK_EQUALS(gt11_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_gt11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt11_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt11_bound = -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(-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_gt11_bound, 
                       "ML_BSSN::gt11", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::gt11!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt11!");
   
   }
   
   if (CCTK_EQUALS(gt12_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_gt12_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt12_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt12_bound = -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(-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_gt12_bound, 
                       "ML_BSSN::gt12", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::gt12!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt12!");
   
   }
   
   if (CCTK_EQUALS(gt13_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_gt13_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt13_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt13_bound = -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(-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_gt13_bound, 
                       "ML_BSSN::gt13", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::gt13!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt13!");
   
   }
   
   if (CCTK_EQUALS(gt22_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_gt22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt22_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt22_bound = -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(-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_gt22_bound, 
                       "ML_BSSN::gt22", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::gt22!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt22!");
   
   }
   
   if (CCTK_EQUALS(gt23_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_gt23_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt23_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt23_bound = -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(-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_gt23_bound, 
                       "ML_BSSN::gt23", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::gt23!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt23!");
   
   }
   
   if (CCTK_EQUALS(gt33_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_gt33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_gt33_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_gt33_bound = -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(-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_gt33_bound, 
                       "ML_BSSN::gt33", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::gt33!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::gt33!");
   
   }
   
   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_BSSN::beta1", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::beta1!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::beta2", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::beta2!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::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_BSSN::beta3", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::beta3!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::beta3!");
   
   }
   
   if (CCTK_EQUALS(trK_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    CCTK_INT handle_trK_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_trK_bound < 0) CCTK_WARN(-1, "could not create table!");
+    static CCTK_INT handle_trK_bound = -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(-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_trK_bound, 
                       "ML_BSSN::trK", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::trK!");
+       CCTK_WARN(0, "Error in registering Scalar BC for ML_BSSN::trK!");
   
   }
   return;
diff --git a/ML_BSSN/src/ML_BSSN_ADMBaseBoundary.c b/ML_BSSN/src/ML_BSSN_ADMBaseBoundary.c
index 5505174..c80dbeb 100644
--- a/ML_BSSN/src/ML_BSSN_ADMBaseBoundary.c
+++ b/ML_BSSN/src/ML_BSSN_ADMBaseBoundary.c
@@ -205,5 +205,5 @@ void ML_BSSN_ADMBaseBoundary(CCTK_ARGUMENTS)
   DECLARE_CCTK_ARGUMENTS
   DECLARE_CCTK_PARAMETERS
   
-  GenericFD_LoopOverBoundary(cctkGH, &ML_BSSN_ADMBaseBoundary_Body);
+  GenericFD_LoopOverBoundaryWithGhosts(cctkGH, &ML_BSSN_ADMBaseBoundary_Body);
 }
diff --git a/ML_BSSN/src/ML_BSSN_boundary.c b/ML_BSSN/src/ML_BSSN_boundary.c
index 638103c..89929d9 100644
--- a/ML_BSSN/src/ML_BSSN_boundary.c
+++ b/ML_BSSN/src/ML_BSSN_boundary.c
@@ -209,5 +209,5 @@ void ML_BSSN_boundary(CCTK_ARGUMENTS)
   DECLARE_CCTK_ARGUMENTS
   DECLARE_CCTK_PARAMETERS
   
-  GenericFD_LoopOverBoundary(cctkGH, &ML_BSSN_boundary_Body);
+  GenericFD_LoopOverBoundaryWithGhosts(cctkGH, &ML_BSSN_boundary_Body);
 }
diff --git a/ML_BSSN/src/ML_BSSN_constraints_boundary.c b/ML_BSSN/src/ML_BSSN_constraints_boundary.c
index a226681..2e69e6d 100644
--- a/ML_BSSN/src/ML_BSSN_constraints_boundary.c
+++ b/ML_BSSN/src/ML_BSSN_constraints_boundary.c
@@ -139,5 +139,5 @@ void ML_BSSN_constraints_boundary(CCTK_ARGUMENTS)
   DECLARE_CCTK_ARGUMENTS
   DECLARE_CCTK_PARAMETERS
   
-  GenericFD_LoopOverBoundary(cctkGH, &ML_BSSN_constraints_boundary_Body);
+  GenericFD_LoopOverBoundaryWithGhosts(cctkGH, &ML_BSSN_constraints_boundary_Body);
 }