Create several specialised thorns: ML_ADM and ML_BSSN as standard cases,

ML_BSSN_MP for multi-patch simulations, and ML_BSSN_M for AMR simulations
with matter.

Add helper thorns for all BSSN thorns.  Helper thorns are required at run
time, e.g. to register gauge conditions.

Split ADM and BSSN equations into their own source files.

8 files changed, 196 insertions, 184 deletions

diff --git a/ML_ADM/interface.ccl b/ML_ADM/interface.ccl
index 79752b5..4b49535 100644
--- a/ML_ADM/interface.ccl
+++ b/ML_ADM/interface.ccl
@@ -5,7 +5,7 @@
 
 implements: ML_ADM
 
-inherits:   ADMBase TmunuBase Grid GenericFD Boundary
+inherits:   ADMBase Grid GenericFD Boundary
 
 
 
@@ -31,21 +31,21 @@ CCTK_INT FUNCTION Boundary_SelectVarForBC(CCTK_POINTER_TO_CONST IN GH, CCTK_INT
 USES FUNCTION Boundary_SelectVarForBC
 
 public:
-CCTK_REAL Ham type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+CCTK_REAL ML_Ham type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
 {
   H
-} "Ham"
+} "ML_Ham"
 
 public:
-CCTK_REAL mom type=GF timelevels=1 tags='tensortypealias="D" tensorweight=1.0000000000000000000'
+CCTK_REAL ML_mom type=GF timelevels=1 tags='tensortypealias="D" tensorweight=1.0000000000000000000'
 {
   M1,
   M2,
   M3
-} "mom"
+} "ML_mom"
 
 public:
-CCTK_REAL ml_curvrhs type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
+CCTK_REAL ML_curvrhs type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
 {
   K11rhs,
   K12rhs,
@@ -53,16 +53,16 @@ CCTK_REAL ml_curvrhs type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorw
   K22rhs,
   K23rhs,
   K33rhs
-} "ml_curvrhs"
+} "ML_curvrhs"
 
 public:
-CCTK_REAL ml_lapserhs type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+CCTK_REAL ML_lapserhs type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
 {
   alpharhs
-} "ml_lapserhs"
+} "ML_lapserhs"
 
 public:
-CCTK_REAL ml_metricrhs type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
+CCTK_REAL ML_metricrhs type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
 {
   g11rhs,
   g12rhs,
@@ -70,18 +70,18 @@ CCTK_REAL ml_metricrhs type=GF timelevels=1 tags='tensortypealias="DD_sym" tenso
   g22rhs,
   g23rhs,
   g33rhs
-} "ml_metricrhs"
+} "ML_metricrhs"
 
 public:
-CCTK_REAL ml_shiftrhs type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
+CCTK_REAL ML_shiftrhs type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
 {
   beta1rhs,
   beta2rhs,
   beta3rhs
-} "ml_shiftrhs"
+} "ML_shiftrhs"
 
 public:
-CCTK_REAL ml_curv type=GF timelevels=3 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
+CCTK_REAL ML_curv type=GF timelevels=3 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
 {
   K11,
   K12,
@@ -89,16 +89,16 @@ CCTK_REAL ml_curv type=GF timelevels=3 tags='tensortypealias="DD_sym" tensorweig
   K22,
   K23,
   K33
-} "ml_curv"
+} "ML_curv"
 
 public:
-CCTK_REAL ml_lapse type=GF timelevels=3 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+CCTK_REAL ML_lapse type=GF timelevels=3 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
 {
   alpha
-} "ml_lapse"
+} "ML_lapse"
 
 public:
-CCTK_REAL ml_metric type=GF timelevels=3 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
+CCTK_REAL ML_metric type=GF timelevels=3 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
 {
   g11,
   g12,
@@ -106,12 +106,12 @@ CCTK_REAL ml_metric type=GF timelevels=3 tags='tensortypealias="DD_sym" tensorwe
   g22,
   g23,
   g33
-} "ml_metric"
+} "ML_metric"
 
 public:
-CCTK_REAL ml_shift type=GF timelevels=3 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
+CCTK_REAL ML_shift type=GF timelevels=3 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
 {
   beta1,
   beta2,
   beta3
-} "ml_shift"
+} "ML_shift"
diff --git a/ML_ADM/param.ccl b/ML_ADM/param.ccl
index 52675c8..660f718 100644
--- a/ML_ADM/param.ccl
+++ b/ML_ADM/param.ccl
@@ -19,9 +19,9 @@ USES CCTK_INT MoL_Num_Evolved_Vars
 USES CCTK_INT MoL_Num_Constrained_Vars
 
 restricted:
-CCTK_REAL verbose "verbose"
+CCTK_INT verbose "verbose"
 {
-  "*:*" :: ""
+  *:* :: ""
 } 0
 
 private:
@@ -47,8 +47,8 @@ CCTK_INT ML_ADM_MaxNumEvolvedVars "Number of evolved variables used by this thor
 restricted:
 CCTK_INT ML_ADM_MaxNumConstrainedVars "Number of constrained variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_Constrained_Vars
 {
-  38:38 :: "Number of constrained variables used by this thorn"
-} 38
+  65:65 :: "Number of constrained variables used by this thorn"
+} 65
 
 restricted:
 CCTK_INT timelevels "Number of active timelevels"
@@ -333,7 +333,7 @@ KEYWORD beta3_bound "Boundary condition to implement"
 } "skip"
 
 private:
-KEYWORD ml_curv_bound "Boundary condition to implement"
+KEYWORD ML_curv_bound "Boundary condition to implement"
 {
   "flat" :: "Flat boundary condition"
   "none" :: "No boundary condition"
@@ -345,7 +345,7 @@ KEYWORD ml_curv_bound "Boundary condition to implement"
 } "skip"
 
 private:
-KEYWORD ml_lapse_bound "Boundary condition to implement"
+KEYWORD ML_lapse_bound "Boundary condition to implement"
 {
   "flat" :: "Flat boundary condition"
   "none" :: "No boundary condition"
@@ -357,7 +357,7 @@ KEYWORD ml_lapse_bound "Boundary condition to implement"
 } "skip"
 
 private:
-KEYWORD ml_metric_bound "Boundary condition to implement"
+KEYWORD ML_metric_bound "Boundary condition to implement"
 {
   "flat" :: "Flat boundary condition"
   "none" :: "No boundary condition"
@@ -369,7 +369,7 @@ KEYWORD ml_metric_bound "Boundary condition to implement"
 } "skip"
 
 private:
-KEYWORD ml_shift_bound "Boundary condition to implement"
+KEYWORD ML_shift_bound "Boundary condition to implement"
 {
   "flat" :: "Flat boundary condition"
   "none" :: "No boundary condition"
@@ -477,25 +477,25 @@ CCTK_REAL beta3_bound_speed "characteristic speed at boundary"
 } 1.
 
 private:
-CCTK_REAL ml_curv_bound_speed "characteristic speed at boundary"
+CCTK_REAL ML_curv_bound_speed "characteristic speed at boundary"
 {
   "0:*" :: "outgoing characteristic speed > 0"
 } 1.
 
 private:
-CCTK_REAL ml_lapse_bound_speed "characteristic speed at boundary"
+CCTK_REAL ML_lapse_bound_speed "characteristic speed at boundary"
 {
   "0:*" :: "outgoing characteristic speed > 0"
 } 1.
 
 private:
-CCTK_REAL ml_metric_bound_speed "characteristic speed at boundary"
+CCTK_REAL ML_metric_bound_speed "characteristic speed at boundary"
 {
   "0:*" :: "outgoing characteristic speed > 0"
 } 1.
 
 private:
-CCTK_REAL ml_shift_bound_speed "characteristic speed at boundary"
+CCTK_REAL ML_shift_bound_speed "characteristic speed at boundary"
 {
   "0:*" :: "outgoing characteristic speed > 0"
 } 1.
@@ -597,25 +597,25 @@ CCTK_REAL beta3_bound_limit "limit value for r -> infinity"
 } 0.
 
 private:
-CCTK_REAL ml_curv_bound_limit "limit value for r -> infinity"
+CCTK_REAL ML_curv_bound_limit "limit value for r -> infinity"
 {
   "*:*" :: "value of limit value is unrestricted"
 } 0.
 
 private:
-CCTK_REAL ml_lapse_bound_limit "limit value for r -> infinity"
+CCTK_REAL ML_lapse_bound_limit "limit value for r -> infinity"
 {
   "*:*" :: "value of limit value is unrestricted"
 } 0.
 
 private:
-CCTK_REAL ml_metric_bound_limit "limit value for r -> infinity"
+CCTK_REAL ML_metric_bound_limit "limit value for r -> infinity"
 {
   "*:*" :: "value of limit value is unrestricted"
 } 0.
 
 private:
-CCTK_REAL ml_shift_bound_limit "limit value for r -> infinity"
+CCTK_REAL ML_shift_bound_limit "limit value for r -> infinity"
 {
   "*:*" :: "value of limit value is unrestricted"
 } 0.
@@ -717,25 +717,25 @@ CCTK_REAL beta3_bound_scalar "Dirichlet boundary value"
 } 0.
 
 private:
-CCTK_REAL ml_curv_bound_scalar "Dirichlet boundary value"
+CCTK_REAL ML_curv_bound_scalar "Dirichlet boundary value"
 {
   "*:*" :: "unrestricted"
 } 0.
 
 private:
-CCTK_REAL ml_lapse_bound_scalar "Dirichlet boundary value"
+CCTK_REAL ML_lapse_bound_scalar "Dirichlet boundary value"
 {
   "*:*" :: "unrestricted"
 } 0.
 
 private:
-CCTK_REAL ml_metric_bound_scalar "Dirichlet boundary value"
+CCTK_REAL ML_metric_bound_scalar "Dirichlet boundary value"
 {
   "*:*" :: "unrestricted"
 } 0.
 
 private:
-CCTK_REAL ml_shift_bound_scalar "Dirichlet boundary value"
+CCTK_REAL ML_shift_bound_scalar "Dirichlet boundary value"
 {
   "*:*" :: "unrestricted"
 } 0.
diff --git a/ML_ADM/schedule.ccl b/ML_ADM/schedule.ccl
index 5dbca42..e5e3c84 100644
--- a/ML_ADM/schedule.ccl
+++ b/ML_ADM/schedule.ccl
@@ -4,68 +4,68 @@
 # Mathematica script written by Ian Hinder and Sascha Husa
 
 
-STORAGE: Ham[1]
+STORAGE: ML_Ham[1]
 
-STORAGE: mom[1]
+STORAGE: ML_mom[1]
 
-STORAGE: ml_curvrhs[1]
+STORAGE: ML_curvrhs[1]
 
-STORAGE: ml_lapserhs[1]
+STORAGE: ML_lapserhs[1]
 
-STORAGE: ml_metricrhs[1]
+STORAGE: ML_metricrhs[1]
 
-STORAGE: ml_shiftrhs[1]
+STORAGE: ML_shiftrhs[1]
 
 if (timelevels == 1)
 {
-  STORAGE: ml_curv[1]
+  STORAGE: ML_curv[1]
 }
 if (timelevels == 2)
 {
-  STORAGE: ml_curv[2]
+  STORAGE: ML_curv[2]
 }
 if (timelevels == 3)
 {
-  STORAGE: ml_curv[3]
+  STORAGE: ML_curv[3]
 }
 
 if (timelevels == 1)
 {
-  STORAGE: ml_lapse[1]
+  STORAGE: ML_lapse[1]
 }
 if (timelevels == 2)
 {
-  STORAGE: ml_lapse[2]
+  STORAGE: ML_lapse[2]
 }
 if (timelevels == 3)
 {
-  STORAGE: ml_lapse[3]
+  STORAGE: ML_lapse[3]
 }
 
 if (timelevels == 1)
 {
-  STORAGE: ml_metric[1]
+  STORAGE: ML_metric[1]
 }
 if (timelevels == 2)
 {
-  STORAGE: ml_metric[2]
+  STORAGE: ML_metric[2]
 }
 if (timelevels == 3)
 {
-  STORAGE: ml_metric[3]
+  STORAGE: ML_metric[3]
 }
 
 if (timelevels == 1)
 {
-  STORAGE: ml_shift[1]
+  STORAGE: ML_shift[1]
 }
 if (timelevels == 2)
 {
-  STORAGE: ml_shift[2]
+  STORAGE: ML_shift[2]
 }
 if (timelevels == 3)
 {
-  STORAGE: ml_shift[3]
+  STORAGE: ML_shift[3]
 }
 
 schedule ML_ADM_Startup at STARTUP
@@ -112,10 +112,10 @@ schedule ML_ADM_RHS IN MoL_CalcRHS
 schedule ML_ADM_RHS AT analysis
 {
   LANG: C
-  SYNC: ml_curvrhs
-  SYNC: ml_lapserhs
-  SYNC: ml_metricrhs
-  SYNC: ml_shiftrhs
+  SYNC: ML_curvrhs
+  SYNC: ML_lapserhs
+  SYNC: ML_metricrhs
+  SYNC: ML_shiftrhs
 } "ML_ADM_RHS"
 
 
@@ -127,7 +127,7 @@ if (CCTK_EQUALS(my_boundary_condition, "Minkowski"))
   } "ML_ADM_boundary"
 }
 
-schedule ML_ADM_convertToADMBase IN MoL_PostStep AFTER (ML_ADM_ApplyBCs ML_ADM_boundary)
+schedule ML_ADM_convertToADMBase IN MoL_PostStep AFTER ML_ADM_ApplyBCs
 {
   LANG: C
 } "ML_ADM_convertToADMBase"
@@ -135,10 +135,10 @@ schedule ML_ADM_convertToADMBase IN MoL_PostStep AFTER (ML_ADM_ApplyBCs ML_ADM_b
 schedule ML_ADM_constraints AT analysis
 {
   LANG: C
-  SYNC: Ham
-  SYNC: mom
-  TRIGGERS: Ham
-  TRIGGERS: mom
+  SYNC: ML_Ham
+  SYNC: ML_mom
+  TRIGGERS: ML_Ham
+  TRIGGERS: ML_mom
 } "ML_ADM_constraints"
 
 schedule ML_ADM_constraints_boundary AT analysis AFTER ML_ADM_constraints
@@ -150,10 +150,10 @@ schedule ML_ADM_ApplyBoundConds in MoL_PostStep
 {
   LANG: C
   OPTIONS: level
-  SYNC: ml_curv
-  SYNC: ml_lapse
-  SYNC: ml_metric
-  SYNC: ml_shift
+  SYNC: ML_curv
+  SYNC: ML_lapse
+  SYNC: ML_metric
+  SYNC: ML_shift
 } "apply boundary conditions"
 
 schedule ML_ADM_CheckBoundaries at BASEGRID
diff --git a/ML_ADM/src/Boundaries.c b/ML_ADM/src/Boundaries.c
index 956080a..c2971da 100644
--- a/ML_ADM/src/Boundaries.c
+++ b/ML_ADM/src/Boundaries.c
@@ -35,48 +35,48 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
   
   CCTK_INT ierr = 0;
   
-  if (CCTK_EQUALS(ml_curv_bound, "none"  ) ||
-      CCTK_EQUALS(ml_curv_bound, "static") ||
-      CCTK_EQUALS(ml_curv_bound, "flat"  ) ||
-      CCTK_EQUALS(ml_curv_bound, "zero"  ) ) 
+  if (CCTK_EQUALS(ML_curv_bound, "none"  ) ||
+      CCTK_EQUALS(ML_curv_bound, "static") ||
+      CCTK_EQUALS(ML_curv_bound, "flat"  ) ||
+      CCTK_EQUALS(ML_curv_bound, "zero"  ) ) 
   {
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::ml_curv", ml_curv_bound);
+                      "ML_ADM::ML_curv", ML_curv_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ml_curv_bound BC for ML_ADM::ml_curv!");
+       CCTK_WARN(0, "Failed to register ML_curv_bound BC for ML_ADM::ML_curv!");
   }
   
-  if (CCTK_EQUALS(ml_lapse_bound, "none"  ) ||
-      CCTK_EQUALS(ml_lapse_bound, "static") ||
-      CCTK_EQUALS(ml_lapse_bound, "flat"  ) ||
-      CCTK_EQUALS(ml_lapse_bound, "zero"  ) ) 
+  if (CCTK_EQUALS(ML_lapse_bound, "none"  ) ||
+      CCTK_EQUALS(ML_lapse_bound, "static") ||
+      CCTK_EQUALS(ML_lapse_bound, "flat"  ) ||
+      CCTK_EQUALS(ML_lapse_bound, "zero"  ) ) 
   {
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::ml_lapse", ml_lapse_bound);
+                      "ML_ADM::ML_lapse", ML_lapse_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ml_lapse_bound BC for ML_ADM::ml_lapse!");
+       CCTK_WARN(0, "Failed to register ML_lapse_bound BC for ML_ADM::ML_lapse!");
   }
   
-  if (CCTK_EQUALS(ml_metric_bound, "none"  ) ||
-      CCTK_EQUALS(ml_metric_bound, "static") ||
-      CCTK_EQUALS(ml_metric_bound, "flat"  ) ||
-      CCTK_EQUALS(ml_metric_bound, "zero"  ) ) 
+  if (CCTK_EQUALS(ML_metric_bound, "none"  ) ||
+      CCTK_EQUALS(ML_metric_bound, "static") ||
+      CCTK_EQUALS(ML_metric_bound, "flat"  ) ||
+      CCTK_EQUALS(ML_metric_bound, "zero"  ) ) 
   {
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::ml_metric", ml_metric_bound);
+                      "ML_ADM::ML_metric", ML_metric_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ml_metric_bound BC for ML_ADM::ml_metric!");
+       CCTK_WARN(0, "Failed to register ML_metric_bound BC for ML_ADM::ML_metric!");
   }
   
-  if (CCTK_EQUALS(ml_shift_bound, "none"  ) ||
-      CCTK_EQUALS(ml_shift_bound, "static") ||
-      CCTK_EQUALS(ml_shift_bound, "flat"  ) ||
-      CCTK_EQUALS(ml_shift_bound, "zero"  ) ) 
+  if (CCTK_EQUALS(ML_shift_bound, "none"  ) ||
+      CCTK_EQUALS(ML_shift_bound, "static") ||
+      CCTK_EQUALS(ML_shift_bound, "flat"  ) ||
+      CCTK_EQUALS(ML_shift_bound, "zero"  ) ) 
   {
     ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::ml_shift", ml_shift_bound);
+                      "ML_ADM::ML_shift", ML_shift_bound);
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register ml_shift_bound BC for ML_ADM::ml_shift!");
+       CCTK_WARN(0, "Failed to register ML_shift_bound BC for ML_ADM::ML_shift!");
   }
   
   if (CCTK_EQUALS(K11_bound, "none"  ) ||
@@ -255,79 +255,79 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
        CCTK_WARN(0, "Failed to register beta3_bound BC for ML_ADM::beta3!");
   }
   
-  if (CCTK_EQUALS(ml_curv_bound, "radiative"))
+  if (CCTK_EQUALS(ML_curv_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    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)
+    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(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ml_curv_bound ,ml_curv_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_curv_bound ,ML_curv_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_curv_bound, 
-                      "ML_ADM::ml_curv", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_curv_bound, 
+                      "ML_ADM::ML_curv", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ml_curv!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ML_curv!");
   
   }
   
-  if (CCTK_EQUALS(ml_lapse_bound, "radiative"))
+  if (CCTK_EQUALS(ML_lapse_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    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)
+    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(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ml_lapse_bound ,ml_lapse_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_lapse_bound ,ML_lapse_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_lapse_bound, 
-                      "ML_ADM::ml_lapse", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_lapse_bound, 
+                      "ML_ADM::ML_lapse", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ml_lapse!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ML_lapse!");
   
   }
   
-  if (CCTK_EQUALS(ml_metric_bound, "radiative"))
+  if (CCTK_EQUALS(ML_metric_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    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)
+    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(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ml_metric_bound ,ml_metric_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_metric_bound ,ML_metric_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_metric_bound, 
-                      "ML_ADM::ml_metric", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_metric_bound, 
+                      "ML_ADM::ML_metric", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ml_metric!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ML_metric!");
   
   }
   
-  if (CCTK_EQUALS(ml_shift_bound, "radiative"))
+  if (CCTK_EQUALS(ML_shift_bound, "radiative"))
   {
    /* apply radiation boundary condition */
-    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)
+    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(0, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_ml_shift_bound ,ml_shift_bound_speed, "SPEED") < 0)
+    if (Util_TableSetReal(handle_ML_shift_bound ,ML_shift_bound_speed, "SPEED") < 0)
        CCTK_WARN(0, "could not set SPEED value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_shift_bound, 
-                      "ML_ADM::ml_shift", "Radiation");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_shift_bound, 
+                      "ML_ADM::ML_shift", "Radiation");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ml_shift!");
+       CCTK_WARN(0, "Failed to register Radiation BC for ML_ADM::ML_shift!");
   
   }
   
@@ -635,71 +635,71 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
   
   }
   
-  if (CCTK_EQUALS(ml_curv_bound, "scalar"))
+  if (CCTK_EQUALS(ML_curv_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    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)
+    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(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_curv_bound, 
-                      "ML_ADM::ml_curv", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_curv_bound, 
+                      "ML_ADM::ML_curv", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ml_curv!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ML_curv!");
   
   }
   
-  if (CCTK_EQUALS(ml_lapse_bound, "scalar"))
+  if (CCTK_EQUALS(ML_lapse_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    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)
+    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(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_lapse_bound, 
-                      "ML_ADM::ml_lapse", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_lapse_bound, 
+                      "ML_ADM::ML_lapse", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ml_lapse!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ML_lapse!");
   
   }
   
-  if (CCTK_EQUALS(ml_metric_bound, "scalar"))
+  if (CCTK_EQUALS(ML_metric_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    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)
+    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(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_metric_bound, 
-                      "ML_ADM::ml_metric", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_metric_bound, 
+                      "ML_ADM::ML_metric", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ml_metric!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ML_metric!");
   
   }
   
-  if (CCTK_EQUALS(ml_shift_bound, "scalar"))
+  if (CCTK_EQUALS(ML_shift_bound, "scalar"))
   {
    /* apply scalar boundary condition */
-    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)
+    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(0, "could not set SCALAR value in table!");
   
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ml_shift_bound, 
-                      "ML_ADM::ml_shift", "scalar");
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_ML_shift_bound, 
+                      "ML_ADM::ML_shift", "scalar");
   
     if (ierr < 0)
-       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ml_shift!");
+       CCTK_WARN(0, "Failed to register Scalar BC for ML_ADM::ML_shift!");
   
   }
   
@@ -980,25 +980,25 @@ void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
 
 
 /* template for entries in parameter file:
-#$bound$#ML_ADM::ml_curv_bound       = "skip"
-#$bound$#ML_ADM::ml_curv_bound_speed = 1.0
-#$bound$#ML_ADM::ml_curv_bound_limit = 0.0
-#$bound$#ML_ADM::ml_curv_bound_scalar = 0.0
+#$bound$#ML_ADM::ML_curv_bound       = "skip"
+#$bound$#ML_ADM::ML_curv_bound_speed = 1.0
+#$bound$#ML_ADM::ML_curv_bound_limit = 0.0
+#$bound$#ML_ADM::ML_curv_bound_scalar = 0.0
 
-#$bound$#ML_ADM::ml_lapse_bound       = "skip"
-#$bound$#ML_ADM::ml_lapse_bound_speed = 1.0
-#$bound$#ML_ADM::ml_lapse_bound_limit = 0.0
-#$bound$#ML_ADM::ml_lapse_bound_scalar = 0.0
+#$bound$#ML_ADM::ML_lapse_bound       = "skip"
+#$bound$#ML_ADM::ML_lapse_bound_speed = 1.0
+#$bound$#ML_ADM::ML_lapse_bound_limit = 0.0
+#$bound$#ML_ADM::ML_lapse_bound_scalar = 0.0
 
-#$bound$#ML_ADM::ml_metric_bound       = "skip"
-#$bound$#ML_ADM::ml_metric_bound_speed = 1.0
-#$bound$#ML_ADM::ml_metric_bound_limit = 0.0
-#$bound$#ML_ADM::ml_metric_bound_scalar = 0.0
+#$bound$#ML_ADM::ML_metric_bound       = "skip"
+#$bound$#ML_ADM::ML_metric_bound_speed = 1.0
+#$bound$#ML_ADM::ML_metric_bound_limit = 0.0
+#$bound$#ML_ADM::ML_metric_bound_scalar = 0.0
 
-#$bound$#ML_ADM::ml_shift_bound       = "skip"
-#$bound$#ML_ADM::ml_shift_bound_speed = 1.0
-#$bound$#ML_ADM::ml_shift_bound_limit = 0.0
-#$bound$#ML_ADM::ml_shift_bound_scalar = 0.0
+#$bound$#ML_ADM::ML_shift_bound       = "skip"
+#$bound$#ML_ADM::ML_shift_bound_speed = 1.0
+#$bound$#ML_ADM::ML_shift_bound_limit = 0.0
+#$bound$#ML_ADM::ML_shift_bound_scalar = 0.0
 
 #$bound$#ML_ADM::K11_bound       = "skip"
 #$bound$#ML_ADM::K11_bound_speed = 1.0
diff --git a/ML_ADM/src/ML_ADM_Minkowski.c b/ML_ADM/src/ML_ADM_Minkowski.c
index 9af8b2e..62e14e2 100644
--- a/ML_ADM/src/ML_ADM_Minkowski.c
+++ b/ML_ADM/src/ML_ADM_Minkowski.c
@@ -5,7 +5,10 @@
 
 #define KRANC_C
 
+#include <assert.h>
 #include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include "cctk.h"
 #include "cctk_Arguments.h"
 #include "cctk_Parameters.h"
@@ -84,7 +87,7 @@ void ML_ADM_Minkowski_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL n
   pm1o12dz2 = -pow(dz,-2)/12.;
   
   /* Loop over the grid points */
-  _Pragma ("omp parallel")
+  #pragma omp parallel
   LC_LOOP3 (ML_ADM_Minkowski,
             i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
             cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
diff --git a/ML_ADM/src/ML_ADM_constraints_boundary.c b/ML_ADM/src/ML_ADM_constraints_boundary.c
index ae07d3b..58854a8 100644
--- a/ML_ADM/src/ML_ADM_constraints_boundary.c
+++ b/ML_ADM/src/ML_ADM_constraints_boundary.c
@@ -5,7 +5,10 @@
 
 #define KRANC_C
 
+#include <assert.h>
 #include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include "cctk.h"
 #include "cctk_Arguments.h"
 #include "cctk_Parameters.h"
@@ -84,7 +87,7 @@ void ML_ADM_constraints_boundary_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face,
   pm1o12dz2 = -pow(dz,-2)/12.;
   
   /* Loop over the grid points */
-  _Pragma ("omp parallel")
+  #pragma omp parallel
   LC_LOOP3 (ML_ADM_constraints_boundary,
             i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
             cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
diff --git a/ML_ADM/src/ML_ADM_convertFromADMBase.c b/ML_ADM/src/ML_ADM_convertFromADMBase.c
index f564d16..82493f6 100644
--- a/ML_ADM/src/ML_ADM_convertFromADMBase.c
+++ b/ML_ADM/src/ML_ADM_convertFromADMBase.c
@@ -5,7 +5,10 @@
 
 #define KRANC_C
 
+#include <assert.h>
 #include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include "cctk.h"
 #include "cctk_Arguments.h"
 #include "cctk_Parameters.h"
@@ -84,7 +87,7 @@ void ML_ADM_convertFromADMBase_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CC
   pm1o12dz2 = -pow(dz,-2)/12.;
   
   /* Loop over the grid points */
-  _Pragma ("omp parallel")
+  #pragma omp parallel
   LC_LOOP3 (ML_ADM_convertFromADMBase,
             i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
             cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
diff --git a/ML_ADM/src/ML_ADM_convertToADMBase.c b/ML_ADM/src/ML_ADM_convertToADMBase.c
index 277235b..4b015f1 100644
--- a/ML_ADM/src/ML_ADM_convertToADMBase.c
+++ b/ML_ADM/src/ML_ADM_convertToADMBase.c
@@ -5,7 +5,10 @@
 
 #define KRANC_C
 
+#include <assert.h>
 #include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include "cctk.h"
 #include "cctk_Arguments.h"
 #include "cctk_Parameters.h"
@@ -84,7 +87,7 @@ void ML_ADM_convertToADMBase_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK
   pm1o12dz2 = -pow(dz,-2)/12.;
   
   /* Loop over the grid points */
-  _Pragma ("omp parallel")
+  #pragma omp parallel
   LC_LOOP3 (ML_ADM_convertToADMBase,
             i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
             cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])