Add BSSN RHS.

Remove Mathematica output trees; keep only Cactus version of trees.

47 files changed, 4653 insertions, 6830 deletions

diff --git a/ML_ADM/schedule.ccl b/ML_ADM/schedule.ccl
index 01a6f4d..0aa9f9d 100644
--- a/ML_ADM/schedule.ccl
+++ b/ML_ADM/schedule.ccl
@@ -55,17 +55,7 @@ if (CCTK_EQUALS(my_initial_data, "Minkowski"))
 
 if (CCTK_EQUALS(my_initial_data, "ADMBase"))
 {
-  schedule ML_ADM_convertFromADMBase AT initial
-  {
-    LANG: C
-    
-  } "ML_ADM_convertFromADMBase"
-}
-
-
-if (CCTK_EQUALS(my_initial_data, "ADMBase"))
-{
-  schedule ML_ADM_convertFromADMBase AFTER ADMBase_PostInitial
+  schedule ML_ADM_convertFromADMBase AT initial AFTER ADMBase_PostInitial
   {
     LANG: C
     
@@ -78,13 +68,17 @@ schedule ML_ADM_RHS IN MoL_CalcRHS
   
 } "ML_ADM_RHS"
 
-schedule ML_ADM_convertToADMBase IN MoL_PostStep
+schedule ML_ADM_RHS AT analysis
 {
   LANG: C
   
-} "ML_ADM_convertToADMBase"
+  SYNC: curvrhs
+  SYNC: lapserhs
+  SYNC: metricrhs
+  SYNC: shiftrhs
+} "ML_ADM_RHS"
 
-schedule ML_ADM_convertToADMBase AFTER ADM_ApplyBoundConds
+schedule ML_ADM_convertToADMBase IN MoL_PostStep AFTER ADM_ApplyBoundConds
 {
   LANG: C
   
diff --git a/ML_ADM/src/ML_ADM_RHS.c b/ML_ADM/src/ML_ADM_RHS.c
index 2b1d7d4..718eedc 100644
--- a/ML_ADM/src/ML_ADM_RHS.c
+++ b/ML_ADM/src/ML_ADM_RHS.c
@@ -532,5 +532,5 @@ void ML_ADM_RHS(CCTK_ARGUMENTS)
   DECLARE_CCTK_ARGUMENTS
   DECLARE_CCTK_PARAMETERS
   
-  GenericFD_LoopOverEverything(cctkGH, &ML_ADM_RHS_Body);
+  GenericFD_LoopOverInterior(cctkGH, &ML_ADM_RHS_Body);
 }
diff --git a/ML_BSSN/interface.ccl b/ML_BSSN/interface.ccl
index d68366c..5dfcf8c 100644
--- a/ML_BSSN/interface.ccl
+++ b/ML_BSSN/interface.ccl
@@ -31,13 +31,13 @@ CCTK_INT FUNCTION Boundary_SelectVarForBC(CCTK_POINTER_TO_CONST IN GH, CCTK_INT
 USES FUNCTION Boundary_SelectVarForBC
 
 public:
-CCTK_REAL cons_detg type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+CCTK_REAL cons_detg type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=2.0000000000000000000'
 {
   cS
 } "cons_detg"
 
 public:
-CCTK_REAL cons_Gamma type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
+CCTK_REAL cons_Gamma type=GF timelevels=1 tags='tensortypealias="U" tensorweight=0.66666666666666666667'
 {
   cXt1,
   cXt2,
@@ -51,7 +51,91 @@ CCTK_REAL cons_traceA type=GF timelevels=1 tags='tensortypealias="Scalar" tensor
 } "cons_traceA"
 
 public:
-CCTK_REAL curv type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
+CCTK_REAL Ham type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+{
+  H
+} "Ham"
+
+public:
+CCTK_REAL mom type=GF timelevels=1 tags='tensortypealias="D" tensorweight=1.0000000000000000000'
+{
+  M1,
+  M2,
+  M3
+} "mom"
+
+public:
+CCTK_REAL curvrhs type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=-0.66666666666666666667'
+{
+  At11rhs,
+  At21rhs,
+  At31rhs,
+  At22rhs,
+  At32rhs,
+  At33rhs
+} "curvrhs"
+
+public:
+CCTK_REAL dtlapserhs type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+{
+  dtalpharhs
+} "dtlapserhs"
+
+public:
+CCTK_REAL dtshiftrhs type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
+{
+  dtbeta1rhs,
+  dtbeta2rhs,
+  dtbeta3rhs
+} "dtshiftrhs"
+
+public:
+CCTK_REAL Gammarhs type=GF timelevels=1 tags='tensortypealias="U" tensorweight=0.66666666666666666667'
+{
+  Xt1rhs,
+  Xt2rhs,
+  Xt3rhs
+} "Gammarhs"
+
+public:
+CCTK_REAL lapserhs type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+{
+  alpharhs
+} "lapserhs"
+
+public:
+CCTK_REAL log_confacrhs type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=0.16666666666666666667'
+{
+  phirhs
+} "log_confacrhs"
+
+public:
+CCTK_REAL metricrhs type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=-0.66666666666666666667'
+{
+  gt11rhs,
+  gt21rhs,
+  gt31rhs,
+  gt22rhs,
+  gt32rhs,
+  gt33rhs
+} "metricrhs"
+
+public:
+CCTK_REAL shiftrhs type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
+{
+  beta1rhs,
+  beta2rhs,
+  beta3rhs
+} "shiftrhs"
+
+public:
+CCTK_REAL trace_curvrhs type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+{
+  trKrhs
+} "trace_curvrhs"
+
+public:
+CCTK_REAL curv type=GF timelevels=3 tags='tensortypealias="DD_sym" tensorweight=-0.66666666666666666667'
 {
   At11,
   At21,
@@ -62,13 +146,13 @@ CCTK_REAL curv type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=
 } "curv"
 
 public:
-CCTK_REAL dtlapse type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+CCTK_REAL dtlapse type=GF timelevels=3 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
 {
   dtalpha
 } "dtlapse"
 
 public:
-CCTK_REAL dtshift type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
+CCTK_REAL dtshift type=GF timelevels=3 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
 {
   dtbeta1,
   dtbeta2,
@@ -76,7 +160,7 @@ CCTK_REAL dtshift type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.
 } "dtshift"
 
 public:
-CCTK_REAL Gamma type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
+CCTK_REAL Gamma type=GF timelevels=3 tags='tensortypealias="U" tensorweight=0.66666666666666666667'
 {
   Xt1,
   Xt2,
@@ -84,25 +168,19 @@ CCTK_REAL Gamma type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.00
 } "Gamma"
 
 public:
-CCTK_REAL Ham type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  H
-} "Ham"
-
-public:
-CCTK_REAL lapse type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+CCTK_REAL lapse type=GF timelevels=3 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
 {
   alpha
 } "lapse"
 
 public:
-CCTK_REAL log_confac type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+CCTK_REAL log_confac type=GF timelevels=3 tags='tensortypealias="Scalar" tensorweight=0.16666666666666666667'
 {
   phi
 } "log_confac"
 
 public:
-CCTK_REAL metric type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
+CCTK_REAL metric type=GF timelevels=3 tags='tensortypealias="DD_sym" tensorweight=-0.66666666666666666667'
 {
   gt11,
   gt21,
@@ -113,15 +191,7 @@ CCTK_REAL metric type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweigh
 } "metric"
 
 public:
-CCTK_REAL mom type=GF timelevels=1 tags='tensortypealias="D" tensorweight=1.0000000000000000000'
-{
-  M1,
-  M2,
-  M3
-} "mom"
-
-public:
-CCTK_REAL shift type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
+CCTK_REAL shift type=GF timelevels=3 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
 {
   beta1,
   beta2,
@@ -129,7 +199,7 @@ CCTK_REAL shift type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.00
 } "shift"
 
 public:
-CCTK_REAL trace_curv type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
+CCTK_REAL trace_curv type=GF timelevels=3 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
 {
   trK
 } "trace_curv"
diff --git a/ML_BSSN/param.ccl b/ML_BSSN/param.ccl
index 58a43b8..918049a 100644
--- a/ML_BSSN/param.ccl
+++ b/ML_BSSN/param.ccl
@@ -39,14 +39,14 @@ KEYWORD my_initial_data "my_initial_data"
 restricted:
 CCTK_INT ML_BSSN_MaxNumEvolvedVars "Number of evolved variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_Evolved_Vars
 {
-  0:0 :: "Number of evolved variables used by this thorn"
-} 0
+  25:25 :: "Number of evolved variables used by this thorn"
+} 25
 
 restricted:
 CCTK_INT ML_BSSN_MaxNumConstrainedVars "Number of constrained variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_Constrained_Vars
 {
-  58:58 :: "Number of constrained variables used by this thorn"
-} 58
+  33:33 :: "Number of constrained variables used by this thorn"
+} 33
 
 restricted:
 CCTK_INT ML_BSSN_Minkowski_calc_every "ML_BSSN_Minkowski_calc_every"
@@ -67,6 +67,12 @@ CCTK_INT ML_BSSN_convertFromADMBaseGamma_calc_every "ML_BSSN_convertFromADMBaseG
 } 1
 
 restricted:
+CCTK_INT ML_BSSN_RHS_calc_every "ML_BSSN_RHS_calc_every"
+{
+  *:* :: "no restrictions"
+} 1
+
+restricted:
 CCTK_INT ML_BSSN_enforce_calc_every "ML_BSSN_enforce_calc_every"
 {
   *:* :: "no restrictions"
@@ -103,6 +109,12 @@ CCTK_INT ML_BSSN_convertFromADMBaseGamma_calc_offset "ML_BSSN_convertFromADMBase
 } 0
 
 restricted:
+CCTK_INT ML_BSSN_RHS_calc_offset "ML_BSSN_RHS_calc_offset"
+{
+  *:* :: "no restrictions"
+} 0
+
+restricted:
 CCTK_INT ML_BSSN_enforce_calc_offset "ML_BSSN_enforce_calc_offset"
 {
   *:* :: "no restrictions"
@@ -120,3 +132,1023 @@ CCTK_INT ML_BSSN_constraints_calc_offset "ML_BSSN_constraints_calc_offset"
   *:* :: "no restrictions"
 } 0
 
+private:
+KEYWORD At11_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD At21_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD At31_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD At22_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD At32_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD At33_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD dtalpha_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD dtbeta1_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD dtbeta2_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD dtbeta3_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD Xt1_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD Xt2_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD Xt3_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD alpha_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD phi_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD gt11_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD gt21_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD gt31_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD gt22_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD gt32_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD gt33_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD beta1_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD beta2_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD beta3_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD trK_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD curv_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD dtlapse_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD dtshift_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD Gamma_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD lapse_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD log_confac_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD metric_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD shift_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+KEYWORD trace_curv_bound "Boundary condition to implement"
+{
+  "flat" :: "Flat boundary condition"
+  "none" :: "No boundary condition"
+  "static" :: "Boundaries held fixed"
+  "radiative" :: "Radiation boundary condition"
+  "scalar" :: "Dirichlet boundary condition"
+  "newrad" :: "Improved radiative boundary condition"
+  "skip" :: "skip boundary condition code"
+} "skip"
+
+private:
+CCTK_REAL At11_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL At21_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL At31_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL At22_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL At32_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL At33_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL dtalpha_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL dtbeta1_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL dtbeta2_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL dtbeta3_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL Xt1_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL Xt2_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL Xt3_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL alpha_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL phi_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL gt11_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL gt21_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL gt31_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL gt22_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL gt32_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL gt33_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL beta1_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL beta2_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL beta3_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL trK_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL curv_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL dtlapse_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL dtshift_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL Gamma_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL lapse_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL log_confac_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL metric_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL shift_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL trace_curv_bound_speed "characteristic speed at boundary"
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL At11_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL At21_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL At31_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL At22_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL At32_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL At33_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtalpha_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtbeta1_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtbeta2_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtbeta3_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL Xt1_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL Xt2_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL Xt3_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL alpha_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL phi_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt11_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt21_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt31_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt22_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt32_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt33_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL beta1_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL beta2_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL beta3_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL trK_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL curv_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtlapse_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtshift_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL Gamma_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL lapse_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL log_confac_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL metric_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL shift_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL trace_curv_bound_limit "limit value for r -> infinity"
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL At11_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL At21_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL At31_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL At22_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL At32_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL At33_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtalpha_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtbeta1_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtbeta2_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtbeta3_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL Xt1_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL Xt2_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL Xt3_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL alpha_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL phi_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt11_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt21_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt31_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt22_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt32_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL gt33_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL beta1_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL beta2_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL beta3_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL trK_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL curv_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtlapse_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL dtshift_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL Gamma_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL lapse_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL log_confac_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL metric_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL shift_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL trace_curv_bound_scalar "Dirichlet boundary value"
+{
+  "*:*" :: "unrestricted"
+} 0.
+
diff --git a/ML_BSSN/schedule.ccl b/ML_BSSN/schedule.ccl
index 98438ed..a185b4d 100644
--- a/ML_BSSN/schedule.ccl
+++ b/ML_BSSN/schedule.ccl
@@ -10,27 +10,45 @@ STORAGE: cons_Gamma[1]
 
 STORAGE: cons_traceA[1]
 
-STORAGE: curv[1]
+STORAGE: Ham[1]
 
-STORAGE: dtlapse[1]
+STORAGE: mom[1]
 
-STORAGE: dtshift[1]
+STORAGE: curvrhs[1]
 
-STORAGE: Gamma[1]
+STORAGE: dtlapserhs[1]
 
-STORAGE: Ham[1]
+STORAGE: dtshiftrhs[1]
 
-STORAGE: lapse[1]
+STORAGE: Gammarhs[1]
 
-STORAGE: log_confac[1]
+STORAGE: lapserhs[1]
 
-STORAGE: metric[1]
+STORAGE: log_confacrhs[1]
 
-STORAGE: mom[1]
+STORAGE: metricrhs[1]
+
+STORAGE: shiftrhs[1]
+
+STORAGE: trace_curvrhs[1]
+
+STORAGE: curv[3]
+
+STORAGE: dtlapse[3]
+
+STORAGE: dtshift[3]
 
-STORAGE: shift[1]
+STORAGE: Gamma[3]
 
-STORAGE: trace_curv[1]
+STORAGE: lapse[3]
+
+STORAGE: log_confac[3]
+
+STORAGE: metric[3]
+
+STORAGE: shift[3]
+
+STORAGE: trace_curv[3]
 
 schedule ML_BSSN_Startup at STARTUP
 {
@@ -63,17 +81,7 @@ if (CCTK_EQUALS(my_initial_data, "Minkowski"))
 
 if (CCTK_EQUALS(my_initial_data, "ADMBase"))
 {
-  schedule ML_BSSN_convertFromADMBase AT initial
-  {
-    LANG: C
-    
-  } "ML_BSSN_convertFromADMBase"
-}
-
-
-if (CCTK_EQUALS(my_initial_data, "ADMBase"))
-{
-  schedule ML_BSSN_convertFromADMBase AFTER ADMBase_PostInitial
+  schedule ML_BSSN_convertFromADMBase AT initial AFTER ADMBase_PostInitial
   {
     LANG: C
     
@@ -83,7 +91,7 @@ if (CCTK_EQUALS(my_initial_data, "ADMBase"))
 
 if (CCTK_EQUALS(my_initial_data, "ADMBase"))
 {
-  schedule ML_BSSN_convertFromADMBaseGamma AT initial
+  schedule ML_BSSN_convertFromADMBaseGamma AT initial AFTER ML_BSSN_convertFromADMBase
   {
     LANG: C
     
@@ -91,30 +99,34 @@ if (CCTK_EQUALS(my_initial_data, "ADMBase"))
   } "ML_BSSN_convertFromADMBaseGamma"
 }
 
-
-if (CCTK_EQUALS(my_initial_data, "ADMBase"))
+schedule ML_BSSN_RHS IN MoL_CalcRHS
 {
-  schedule ML_BSSN_convertFromADMBaseGamma AFTER ML_BSSN_convertFromADMBase
-  {
-    LANG: C
-    
-    SYNC: Gamma
-  } "ML_BSSN_convertFromADMBaseGamma"
-}
+  LANG: C
+  
+} "ML_BSSN_RHS"
 
-schedule ML_BSSN_enforce IN MoL_PostStep
+schedule ML_BSSN_RHS AT analysis
 {
   LANG: C
   
-} "ML_BSSN_enforce"
-
-schedule ML_BSSN_convertToADMBase IN MoL_PostStep
+  SYNC: curvrhs
+  SYNC: dtlapserhs
+  SYNC: dtshiftrhs
+  SYNC: Gammarhs
+  SYNC: lapserhs
+  SYNC: log_confacrhs
+  SYNC: metricrhs
+  SYNC: shiftrhs
+  SYNC: trace_curvrhs
+} "ML_BSSN_RHS"
+
+schedule ML_BSSN_enforce IN MoL_PostStep AFTER BSSN_ApplyBoundConds
 {
   LANG: C
   
-} "ML_BSSN_convertToADMBase"
+} "ML_BSSN_enforce"
 
-schedule ML_BSSN_convertToADMBase AFTER ML_ADM_ApplyBoundConds
+schedule ML_BSSN_convertToADMBase IN MoL_PostStep AFTER ML_BSSN_ApplyBoundConds AFTER ML_BSSN_enforce
 {
   LANG: C
   
@@ -135,6 +147,15 @@ schedule ML_BSSN_ApplyBoundConds in MoL_PostStep
 {
   LANG: C
   OPTIONS: level
+  SYNC: curv
+  SYNC: dtlapse
+  SYNC: dtshift
+  SYNC: Gamma
+  SYNC: lapse
+  SYNC: log_confac
+  SYNC: metric
+  SYNC: shift
+  SYNC: trace_curv
 } "apply boundary conditions"
 
 schedule ML_BSSN_CheckBoundaries at BASEGRID
diff --git a/ML_BSSN/src/Boundaries.c b/ML_BSSN/src/Boundaries.c
index cd2f9aa..a5456e9 100644
--- a/ML_BSSN/src/Boundaries.c
+++ b/ML_BSSN/src/Boundaries.c
@@ -34,11 +34,1711 @@ void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
   DECLARE_CCTK_PARAMETERS
   
   CCTK_INT ierr = 0;
+  
+  if (CCTK_EQUALS(curv_bound, "none"  ) ||
+      CCTK_EQUALS(curv_bound, "static") ||
+      CCTK_EQUALS(curv_bound, "flat"  ) ||
+      CCTK_EQUALS(curv_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::curv", curv_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register curv_bound BC for ML_BSSN::curv!");
+  }
+  
+  if (CCTK_EQUALS(dtlapse_bound, "none"  ) ||
+      CCTK_EQUALS(dtlapse_bound, "static") ||
+      CCTK_EQUALS(dtlapse_bound, "flat"  ) ||
+      CCTK_EQUALS(dtlapse_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::dtlapse", dtlapse_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register dtlapse_bound BC for ML_BSSN::dtlapse!");
+  }
+  
+  if (CCTK_EQUALS(dtshift_bound, "none"  ) ||
+      CCTK_EQUALS(dtshift_bound, "static") ||
+      CCTK_EQUALS(dtshift_bound, "flat"  ) ||
+      CCTK_EQUALS(dtshift_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::dtshift", dtshift_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register dtshift_bound BC for ML_BSSN::dtshift!");
+  }
+  
+  if (CCTK_EQUALS(Gamma_bound, "none"  ) ||
+      CCTK_EQUALS(Gamma_bound, "static") ||
+      CCTK_EQUALS(Gamma_bound, "flat"  ) ||
+      CCTK_EQUALS(Gamma_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::Gamma", Gamma_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Gamma_bound BC for ML_BSSN::Gamma!");
+  }
+  
+  if (CCTK_EQUALS(lapse_bound, "none"  ) ||
+      CCTK_EQUALS(lapse_bound, "static") ||
+      CCTK_EQUALS(lapse_bound, "flat"  ) ||
+      CCTK_EQUALS(lapse_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::lapse", lapse_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register lapse_bound BC for ML_BSSN::lapse!");
+  }
+  
+  if (CCTK_EQUALS(log_confac_bound, "none"  ) ||
+      CCTK_EQUALS(log_confac_bound, "static") ||
+      CCTK_EQUALS(log_confac_bound, "flat"  ) ||
+      CCTK_EQUALS(log_confac_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::log_confac", log_confac_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register log_confac_bound BC for ML_BSSN::log_confac!");
+  }
+  
+  if (CCTK_EQUALS(metric_bound, "none"  ) ||
+      CCTK_EQUALS(metric_bound, "static") ||
+      CCTK_EQUALS(metric_bound, "flat"  ) ||
+      CCTK_EQUALS(metric_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::metric", metric_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register metric_bound BC for ML_BSSN::metric!");
+  }
+  
+  if (CCTK_EQUALS(shift_bound, "none"  ) ||
+      CCTK_EQUALS(shift_bound, "static") ||
+      CCTK_EQUALS(shift_bound, "flat"  ) ||
+      CCTK_EQUALS(shift_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::shift", shift_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register shift_bound BC for ML_BSSN::shift!");
+  }
+  
+  if (CCTK_EQUALS(trace_curv_bound, "none"  ) ||
+      CCTK_EQUALS(trace_curv_bound, "static") ||
+      CCTK_EQUALS(trace_curv_bound, "flat"  ) ||
+      CCTK_EQUALS(trace_curv_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::trace_curv", trace_curv_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register trace_curv_bound BC for ML_BSSN::trace_curv!");
+  }
+  
+  if (CCTK_EQUALS(At11_bound, "none"  ) ||
+      CCTK_EQUALS(At11_bound, "static") ||
+      CCTK_EQUALS(At11_bound, "flat"  ) ||
+      CCTK_EQUALS(At11_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::At11", At11_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register At11_bound BC for ML_BSSN::At11!");
+  }
+  
+  if (CCTK_EQUALS(At21_bound, "none"  ) ||
+      CCTK_EQUALS(At21_bound, "static") ||
+      CCTK_EQUALS(At21_bound, "flat"  ) ||
+      CCTK_EQUALS(At21_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::At21", At21_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register At21_bound BC for ML_BSSN::At21!");
+  }
+  
+  if (CCTK_EQUALS(At31_bound, "none"  ) ||
+      CCTK_EQUALS(At31_bound, "static") ||
+      CCTK_EQUALS(At31_bound, "flat"  ) ||
+      CCTK_EQUALS(At31_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::At31", At31_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register At31_bound BC for ML_BSSN::At31!");
+  }
+  
+  if (CCTK_EQUALS(At22_bound, "none"  ) ||
+      CCTK_EQUALS(At22_bound, "static") ||
+      CCTK_EQUALS(At22_bound, "flat"  ) ||
+      CCTK_EQUALS(At22_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::At22", At22_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register At22_bound BC for ML_BSSN::At22!");
+  }
+  
+  if (CCTK_EQUALS(At32_bound, "none"  ) ||
+      CCTK_EQUALS(At32_bound, "static") ||
+      CCTK_EQUALS(At32_bound, "flat"  ) ||
+      CCTK_EQUALS(At32_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::At32", At32_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register At32_bound BC for ML_BSSN::At32!");
+  }
+  
+  if (CCTK_EQUALS(At33_bound, "none"  ) ||
+      CCTK_EQUALS(At33_bound, "static") ||
+      CCTK_EQUALS(At33_bound, "flat"  ) ||
+      CCTK_EQUALS(At33_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::At33", At33_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register At33_bound BC for ML_BSSN::At33!");
+  }
+  
+  if (CCTK_EQUALS(dtalpha_bound, "none"  ) ||
+      CCTK_EQUALS(dtalpha_bound, "static") ||
+      CCTK_EQUALS(dtalpha_bound, "flat"  ) ||
+      CCTK_EQUALS(dtalpha_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::dtalpha", dtalpha_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register dtalpha_bound BC for ML_BSSN::dtalpha!");
+  }
+  
+  if (CCTK_EQUALS(dtbeta1_bound, "none"  ) ||
+      CCTK_EQUALS(dtbeta1_bound, "static") ||
+      CCTK_EQUALS(dtbeta1_bound, "flat"  ) ||
+      CCTK_EQUALS(dtbeta1_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::dtbeta1", dtbeta1_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register dtbeta1_bound BC for ML_BSSN::dtbeta1!");
+  }
+  
+  if (CCTK_EQUALS(dtbeta2_bound, "none"  ) ||
+      CCTK_EQUALS(dtbeta2_bound, "static") ||
+      CCTK_EQUALS(dtbeta2_bound, "flat"  ) ||
+      CCTK_EQUALS(dtbeta2_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::dtbeta2", dtbeta2_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register dtbeta2_bound BC for ML_BSSN::dtbeta2!");
+  }
+  
+  if (CCTK_EQUALS(dtbeta3_bound, "none"  ) ||
+      CCTK_EQUALS(dtbeta3_bound, "static") ||
+      CCTK_EQUALS(dtbeta3_bound, "flat"  ) ||
+      CCTK_EQUALS(dtbeta3_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::dtbeta3", dtbeta3_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register dtbeta3_bound BC for ML_BSSN::dtbeta3!");
+  }
+  
+  if (CCTK_EQUALS(Xt1_bound, "none"  ) ||
+      CCTK_EQUALS(Xt1_bound, "static") ||
+      CCTK_EQUALS(Xt1_bound, "flat"  ) ||
+      CCTK_EQUALS(Xt1_bound, "zero"  ) ) 
+  {
+    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!");
+  }
+  
+  if (CCTK_EQUALS(Xt2_bound, "none"  ) ||
+      CCTK_EQUALS(Xt2_bound, "static") ||
+      CCTK_EQUALS(Xt2_bound, "flat"  ) ||
+      CCTK_EQUALS(Xt2_bound, "zero"  ) ) 
+  {
+    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!");
+  }
+  
+  if (CCTK_EQUALS(Xt3_bound, "none"  ) ||
+      CCTK_EQUALS(Xt3_bound, "static") ||
+      CCTK_EQUALS(Xt3_bound, "flat"  ) ||
+      CCTK_EQUALS(Xt3_bound, "zero"  ) ) 
+  {
+    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!");
+  }
+  
+  if (CCTK_EQUALS(alpha_bound, "none"  ) ||
+      CCTK_EQUALS(alpha_bound, "static") ||
+      CCTK_EQUALS(alpha_bound, "flat"  ) ||
+      CCTK_EQUALS(alpha_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::alpha", alpha_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register alpha_bound BC for ML_BSSN::alpha!");
+  }
+  
+  if (CCTK_EQUALS(phi_bound, "none"  ) ||
+      CCTK_EQUALS(phi_bound, "static") ||
+      CCTK_EQUALS(phi_bound, "flat"  ) ||
+      CCTK_EQUALS(phi_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::phi", phi_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register phi_bound BC for ML_BSSN::phi!");
+  }
+  
+  if (CCTK_EQUALS(gt11_bound, "none"  ) ||
+      CCTK_EQUALS(gt11_bound, "static") ||
+      CCTK_EQUALS(gt11_bound, "flat"  ) ||
+      CCTK_EQUALS(gt11_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::gt11", gt11_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register gt11_bound BC for ML_BSSN::gt11!");
+  }
+  
+  if (CCTK_EQUALS(gt21_bound, "none"  ) ||
+      CCTK_EQUALS(gt21_bound, "static") ||
+      CCTK_EQUALS(gt21_bound, "flat"  ) ||
+      CCTK_EQUALS(gt21_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::gt21", gt21_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register gt21_bound BC for ML_BSSN::gt21!");
+  }
+  
+  if (CCTK_EQUALS(gt31_bound, "none"  ) ||
+      CCTK_EQUALS(gt31_bound, "static") ||
+      CCTK_EQUALS(gt31_bound, "flat"  ) ||
+      CCTK_EQUALS(gt31_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::gt31", gt31_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register gt31_bound BC for ML_BSSN::gt31!");
+  }
+  
+  if (CCTK_EQUALS(gt22_bound, "none"  ) ||
+      CCTK_EQUALS(gt22_bound, "static") ||
+      CCTK_EQUALS(gt22_bound, "flat"  ) ||
+      CCTK_EQUALS(gt22_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::gt22", gt22_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register gt22_bound BC for ML_BSSN::gt22!");
+  }
+  
+  if (CCTK_EQUALS(gt32_bound, "none"  ) ||
+      CCTK_EQUALS(gt32_bound, "static") ||
+      CCTK_EQUALS(gt32_bound, "flat"  ) ||
+      CCTK_EQUALS(gt32_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::gt32", gt32_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register gt32_bound BC for ML_BSSN::gt32!");
+  }
+  
+  if (CCTK_EQUALS(gt33_bound, "none"  ) ||
+      CCTK_EQUALS(gt33_bound, "static") ||
+      CCTK_EQUALS(gt33_bound, "flat"  ) ||
+      CCTK_EQUALS(gt33_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::gt33", gt33_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register gt33_bound BC for ML_BSSN::gt33!");
+  }
+  
+  if (CCTK_EQUALS(beta1_bound, "none"  ) ||
+      CCTK_EQUALS(beta1_bound, "static") ||
+      CCTK_EQUALS(beta1_bound, "flat"  ) ||
+      CCTK_EQUALS(beta1_bound, "zero"  ) ) 
+  {
+    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!");
+  }
+  
+  if (CCTK_EQUALS(beta2_bound, "none"  ) ||
+      CCTK_EQUALS(beta2_bound, "static") ||
+      CCTK_EQUALS(beta2_bound, "flat"  ) ||
+      CCTK_EQUALS(beta2_bound, "zero"  ) ) 
+  {
+    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!");
+  }
+  
+  if (CCTK_EQUALS(beta3_bound, "none"  ) ||
+      CCTK_EQUALS(beta3_bound, "static") ||
+      CCTK_EQUALS(beta3_bound, "flat"  ) ||
+      CCTK_EQUALS(beta3_bound, "zero"  ) ) 
+  {
+    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!");
+  }
+  
+  if (CCTK_EQUALS(trK_bound, "none"  ) ||
+      CCTK_EQUALS(trK_bound, "static") ||
+      CCTK_EQUALS(trK_bound, "flat"  ) ||
+      CCTK_EQUALS(trK_bound, "zero"  ) ) 
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
+                      "ML_BSSN::trK", trK_bound);
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register trK_bound BC for ML_BSSN::trK!");
+  }
+  
+  if (CCTK_EQUALS(curv_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_curv_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_curv_bound , curv_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_curv_bound ,curv_bound_speed, "SPEED") < 0)
+       CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_curv_bound, 
+                      "ML_BSSN::curv", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::curv!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtlapse_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_dtlapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtlapse_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtlapse_bound , dtlapse_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_dtlapse_bound ,dtlapse_bound_speed, "SPEED") < 0)
+       CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtlapse_bound, 
+                      "ML_BSSN::dtlapse", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::dtlapse!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtshift_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_dtshift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtshift_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtshift_bound , dtshift_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_dtshift_bound ,dtshift_bound_speed, "SPEED") < 0)
+       CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtshift_bound, 
+                      "ML_BSSN::dtshift", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::dtshift!");
+  
+  }
+  
+  if (CCTK_EQUALS(Gamma_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_Gamma_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_Gamma_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_Gamma_bound , Gamma_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_Gamma_bound ,Gamma_bound_speed, "SPEED") < 0)
+       CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_Gamma_bound, 
+                      "ML_BSSN::Gamma", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::Gamma!");
+  
+  }
+  
+  if (CCTK_EQUALS(lapse_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_lapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_lapse_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_lapse_bound , lapse_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_lapse_bound ,lapse_bound_speed, "SPEED") < 0)
+       CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_lapse_bound, 
+                      "ML_BSSN::lapse", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::lapse!");
+  
+  }
+  
+  if (CCTK_EQUALS(log_confac_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_log_confac_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_log_confac_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_log_confac_bound , log_confac_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_log_confac_bound ,log_confac_bound_speed, "SPEED") < 0)
+       CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_log_confac_bound, 
+                      "ML_BSSN::log_confac", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::log_confac!");
+  
+  }
+  
+  if (CCTK_EQUALS(metric_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_metric_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_metric_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_metric_bound , metric_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_metric_bound ,metric_bound_speed, "SPEED") < 0)
+       CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_metric_bound, 
+                      "ML_BSSN::metric", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::metric!");
+  
+  }
+  
+  if (CCTK_EQUALS(shift_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_shift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_shift_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_shift_bound , shift_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_shift_bound ,shift_bound_speed, "SPEED") < 0)
+       CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_shift_bound, 
+                      "ML_BSSN::shift", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::shift!");
+  
+  }
+  
+  if (CCTK_EQUALS(trace_curv_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_trace_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_trace_curv_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_trace_curv_bound , trace_curv_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_trace_curv_bound ,trace_curv_bound_speed, "SPEED") < 0)
+       CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_trace_curv_bound, 
+                      "ML_BSSN::trace_curv", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::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!");
+    if (Util_TableSetReal(handle_At11_bound , At11_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  if (CCTK_EQUALS(At21_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_At21_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At21_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_At21_bound , At21_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_At21_bound ,At21_bound_speed, "SPEED") < 0)
+        CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At21_bound, 
+                      "ML_BSSN::At21", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::At21!");
+  
+  }
+  
+  if (CCTK_EQUALS(At31_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_At31_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At31_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_At31_bound , At31_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_At31_bound ,At31_bound_speed, "SPEED") < 0)
+        CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At31_bound, 
+                      "ML_BSSN::At31", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::At31!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_At22_bound , At22_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  if (CCTK_EQUALS(At32_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_At32_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At32_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_At32_bound , At32_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_At32_bound ,At32_bound_speed, "SPEED") < 0)
+        CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At32_bound, 
+                      "ML_BSSN::At32", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::At32!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_At33_bound , At33_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtalpha_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_dtalpha_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtalpha_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtalpha_bound , dtalpha_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_dtalpha_bound ,dtalpha_bound_speed, "SPEED") < 0)
+        CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtalpha_bound, 
+                      "ML_BSSN::dtalpha", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::dtalpha!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtbeta1_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_dtbeta1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtbeta1_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtbeta1_bound , dtbeta1_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_dtbeta1_bound ,dtbeta1_bound_speed, "SPEED") < 0)
+        CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtbeta1_bound, 
+                      "ML_BSSN::dtbeta1", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::dtbeta1!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtbeta2_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_dtbeta2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtbeta2_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtbeta2_bound , dtbeta2_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_dtbeta2_bound ,dtbeta2_bound_speed, "SPEED") < 0)
+        CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtbeta2_bound, 
+                      "ML_BSSN::dtbeta2", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::dtbeta2!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtbeta3_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_dtbeta3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtbeta3_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtbeta3_bound , dtbeta3_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_dtbeta3_bound ,dtbeta3_bound_speed, "SPEED") < 0)
+        CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtbeta3_bound, 
+                      "ML_BSSN::dtbeta3", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::dtbeta3!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_Xt1_bound , Xt1_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_Xt2_bound , Xt2_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_Xt3_bound , Xt3_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_alpha_bound , alpha_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_phi_bound , phi_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_gt11_bound , gt11_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  if (CCTK_EQUALS(gt21_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_gt21_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt21_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_gt21_bound , gt21_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_gt21_bound ,gt21_bound_speed, "SPEED") < 0)
+        CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt21_bound, 
+                      "ML_BSSN::gt21", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::gt21!");
+  
+  }
+  
+  if (CCTK_EQUALS(gt31_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_gt31_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt31_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_gt31_bound , gt31_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_gt31_bound ,gt31_bound_speed, "SPEED") < 0)
+        CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt31_bound, 
+                      "ML_BSSN::gt31", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::gt31!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_gt22_bound , gt22_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  if (CCTK_EQUALS(gt32_bound, "radiative"))
+  {
+   /* apply radiation boundary condition */
+    CCTK_INT handle_gt32_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt32_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_gt32_bound , gt32_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_gt32_bound ,gt32_bound_speed, "SPEED") < 0)
+        CCTK_WARN(-1, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt32_bound, 
+                      "ML_BSSN::gt32", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Radiation BC for ML_BSSN::gt32!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_gt33_bound , gt33_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_beta1_bound , beta1_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_beta2_bound , beta2_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_beta3_bound , beta3_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_trK_bound , trK_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(-1, "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!");
+  
+    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!");
+  
+  }
+  
+  if (CCTK_EQUALS(curv_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_curv_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_curv_bound ,curv_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_curv_bound, 
+                      "ML_BSSN::curv", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::curv!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtlapse_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_dtlapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtlapse_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtlapse_bound ,dtlapse_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtlapse_bound, 
+                      "ML_BSSN::dtlapse", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::dtlapse!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtshift_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_dtshift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtshift_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtshift_bound ,dtshift_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtshift_bound, 
+                      "ML_BSSN::dtshift", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::dtshift!");
+  
+  }
+  
+  if (CCTK_EQUALS(Gamma_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_Gamma_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_Gamma_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_Gamma_bound ,Gamma_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_Gamma_bound, 
+                      "ML_BSSN::Gamma", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::Gamma!");
+  
+  }
+  
+  if (CCTK_EQUALS(lapse_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_lapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_lapse_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_lapse_bound ,lapse_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_lapse_bound, 
+                      "ML_BSSN::lapse", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::lapse!");
+  
+  }
+  
+  if (CCTK_EQUALS(log_confac_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_log_confac_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_log_confac_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_log_confac_bound ,log_confac_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_log_confac_bound, 
+                      "ML_BSSN::log_confac", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::log_confac!");
+  
+  }
+  
+  if (CCTK_EQUALS(metric_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_metric_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_metric_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_metric_bound ,metric_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_metric_bound, 
+                      "ML_BSSN::metric", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::metric!");
+  
+  }
+  
+  if (CCTK_EQUALS(shift_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_shift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_shift_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_shift_bound ,shift_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_shift_bound, 
+                      "ML_BSSN::shift", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::shift!");
+  
+  }
+  
+  if (CCTK_EQUALS(trace_curv_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_trace_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_trace_curv_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_trace_curv_bound ,trace_curv_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_trace_curv_bound, 
+                      "ML_BSSN::trace_curv", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Failed to register Scalar BC for ML_BSSN::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!");
+    if (Util_TableSetReal(handle_At11_bound ,At11_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  if (CCTK_EQUALS(At21_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_At21_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At21_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_At21_bound ,At21_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At21_bound, 
+                      "ML_BSSN::At21", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::At21!");
+  
+  }
+  
+  if (CCTK_EQUALS(At31_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_At31_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At31_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_At31_bound ,At31_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At31_bound, 
+                      "ML_BSSN::At31", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::At31!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_At22_bound ,At22_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  if (CCTK_EQUALS(At32_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_At32_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_At32_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_At32_bound ,At32_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_At32_bound, 
+                      "ML_BSSN::At32", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::At32!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_At33_bound ,At33_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtalpha_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_dtalpha_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtalpha_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtalpha_bound ,dtalpha_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtalpha_bound, 
+                      "ML_BSSN::dtalpha", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::dtalpha!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtbeta1_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_dtbeta1_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtbeta1_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtbeta1_bound ,dtbeta1_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtbeta1_bound, 
+                      "ML_BSSN::dtbeta1", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::dtbeta1!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtbeta2_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_dtbeta2_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtbeta2_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtbeta2_bound ,dtbeta2_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtbeta2_bound, 
+                      "ML_BSSN::dtbeta2", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::dtbeta2!");
+  
+  }
+  
+  if (CCTK_EQUALS(dtbeta3_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_dtbeta3_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_dtbeta3_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_dtbeta3_bound ,dtbeta3_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_dtbeta3_bound, 
+                      "ML_BSSN::dtbeta3", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::dtbeta3!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_Xt1_bound ,Xt1_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_Xt2_bound ,Xt2_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_Xt3_bound ,Xt3_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_alpha_bound ,alpha_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_phi_bound ,phi_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_gt11_bound ,gt11_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  if (CCTK_EQUALS(gt21_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_gt21_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt21_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_gt21_bound ,gt21_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt21_bound, 
+                      "ML_BSSN::gt21", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::gt21!");
+  
+  }
+  
+  if (CCTK_EQUALS(gt31_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_gt31_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt31_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_gt31_bound ,gt31_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt31_bound, 
+                      "ML_BSSN::gt31", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::gt31!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_gt22_bound ,gt22_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  if (CCTK_EQUALS(gt32_bound, "scalar"))
+  {
+   /* apply scalar boundary condition */
+    CCTK_INT handle_gt32_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_gt32_bound < 0) CCTK_WARN(-1, "could not create table!");
+    if (Util_TableSetReal(handle_gt32_bound ,gt32_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_gt32_bound, 
+                      "ML_BSSN::gt32", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(-1, "Error in registering Scalar BC for ML_BSSN::gt32!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_gt33_bound ,gt33_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_beta1_bound ,beta1_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_beta2_bound ,beta2_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_beta3_bound ,beta3_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
+  
+  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!");
+    if (Util_TableSetReal(handle_trK_bound ,trK_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(-1, "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!");
+  
+  }
   return;
 }
 
 
 
 /* template for entries in parameter file:
+#$bound$#ML_BSSN::curv_bound       = "skip"
+#$bound$#ML_BSSN::curv_bound_speed = 1.0
+#$bound$#ML_BSSN::curv_bound_limit = 0.0
+#$bound$#ML_BSSN::curv_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::dtlapse_bound       = "skip"
+#$bound$#ML_BSSN::dtlapse_bound_speed = 1.0
+#$bound$#ML_BSSN::dtlapse_bound_limit = 0.0
+#$bound$#ML_BSSN::dtlapse_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::dtshift_bound       = "skip"
+#$bound$#ML_BSSN::dtshift_bound_speed = 1.0
+#$bound$#ML_BSSN::dtshift_bound_limit = 0.0
+#$bound$#ML_BSSN::dtshift_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::Gamma_bound       = "skip"
+#$bound$#ML_BSSN::Gamma_bound_speed = 1.0
+#$bound$#ML_BSSN::Gamma_bound_limit = 0.0
+#$bound$#ML_BSSN::Gamma_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::lapse_bound       = "skip"
+#$bound$#ML_BSSN::lapse_bound_speed = 1.0
+#$bound$#ML_BSSN::lapse_bound_limit = 0.0
+#$bound$#ML_BSSN::lapse_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::log_confac_bound       = "skip"
+#$bound$#ML_BSSN::log_confac_bound_speed = 1.0
+#$bound$#ML_BSSN::log_confac_bound_limit = 0.0
+#$bound$#ML_BSSN::log_confac_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::metric_bound       = "skip"
+#$bound$#ML_BSSN::metric_bound_speed = 1.0
+#$bound$#ML_BSSN::metric_bound_limit = 0.0
+#$bound$#ML_BSSN::metric_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::shift_bound       = "skip"
+#$bound$#ML_BSSN::shift_bound_speed = 1.0
+#$bound$#ML_BSSN::shift_bound_limit = 0.0
+#$bound$#ML_BSSN::shift_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::trace_curv_bound       = "skip"
+#$bound$#ML_BSSN::trace_curv_bound_speed = 1.0
+#$bound$#ML_BSSN::trace_curv_bound_limit = 0.0
+#$bound$#ML_BSSN::trace_curv_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::At11_bound       = "skip"
+#$bound$#ML_BSSN::At11_bound_speed = 1.0
+#$bound$#ML_BSSN::At11_bound_limit = 0.0
+#$bound$#ML_BSSN::At11_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::At21_bound       = "skip"
+#$bound$#ML_BSSN::At21_bound_speed = 1.0
+#$bound$#ML_BSSN::At21_bound_limit = 0.0
+#$bound$#ML_BSSN::At21_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::At31_bound       = "skip"
+#$bound$#ML_BSSN::At31_bound_speed = 1.0
+#$bound$#ML_BSSN::At31_bound_limit = 0.0
+#$bound$#ML_BSSN::At31_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::At22_bound       = "skip"
+#$bound$#ML_BSSN::At22_bound_speed = 1.0
+#$bound$#ML_BSSN::At22_bound_limit = 0.0
+#$bound$#ML_BSSN::At22_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::At32_bound       = "skip"
+#$bound$#ML_BSSN::At32_bound_speed = 1.0
+#$bound$#ML_BSSN::At32_bound_limit = 0.0
+#$bound$#ML_BSSN::At32_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::At33_bound       = "skip"
+#$bound$#ML_BSSN::At33_bound_speed = 1.0
+#$bound$#ML_BSSN::At33_bound_limit = 0.0
+#$bound$#ML_BSSN::At33_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::dtalpha_bound       = "skip"
+#$bound$#ML_BSSN::dtalpha_bound_speed = 1.0
+#$bound$#ML_BSSN::dtalpha_bound_limit = 0.0
+#$bound$#ML_BSSN::dtalpha_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::dtbeta1_bound       = "skip"
+#$bound$#ML_BSSN::dtbeta1_bound_speed = 1.0
+#$bound$#ML_BSSN::dtbeta1_bound_limit = 0.0
+#$bound$#ML_BSSN::dtbeta1_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::dtbeta2_bound       = "skip"
+#$bound$#ML_BSSN::dtbeta2_bound_speed = 1.0
+#$bound$#ML_BSSN::dtbeta2_bound_limit = 0.0
+#$bound$#ML_BSSN::dtbeta2_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::dtbeta3_bound       = "skip"
+#$bound$#ML_BSSN::dtbeta3_bound_speed = 1.0
+#$bound$#ML_BSSN::dtbeta3_bound_limit = 0.0
+#$bound$#ML_BSSN::dtbeta3_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::Xt1_bound       = "skip"
+#$bound$#ML_BSSN::Xt1_bound_speed = 1.0
+#$bound$#ML_BSSN::Xt1_bound_limit = 0.0
+#$bound$#ML_BSSN::Xt1_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::Xt2_bound       = "skip"
+#$bound$#ML_BSSN::Xt2_bound_speed = 1.0
+#$bound$#ML_BSSN::Xt2_bound_limit = 0.0
+#$bound$#ML_BSSN::Xt2_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::Xt3_bound       = "skip"
+#$bound$#ML_BSSN::Xt3_bound_speed = 1.0
+#$bound$#ML_BSSN::Xt3_bound_limit = 0.0
+#$bound$#ML_BSSN::Xt3_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::alpha_bound       = "skip"
+#$bound$#ML_BSSN::alpha_bound_speed = 1.0
+#$bound$#ML_BSSN::alpha_bound_limit = 0.0
+#$bound$#ML_BSSN::alpha_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::phi_bound       = "skip"
+#$bound$#ML_BSSN::phi_bound_speed = 1.0
+#$bound$#ML_BSSN::phi_bound_limit = 0.0
+#$bound$#ML_BSSN::phi_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::gt11_bound       = "skip"
+#$bound$#ML_BSSN::gt11_bound_speed = 1.0
+#$bound$#ML_BSSN::gt11_bound_limit = 0.0
+#$bound$#ML_BSSN::gt11_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::gt21_bound       = "skip"
+#$bound$#ML_BSSN::gt21_bound_speed = 1.0
+#$bound$#ML_BSSN::gt21_bound_limit = 0.0
+#$bound$#ML_BSSN::gt21_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::gt31_bound       = "skip"
+#$bound$#ML_BSSN::gt31_bound_speed = 1.0
+#$bound$#ML_BSSN::gt31_bound_limit = 0.0
+#$bound$#ML_BSSN::gt31_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::gt22_bound       = "skip"
+#$bound$#ML_BSSN::gt22_bound_speed = 1.0
+#$bound$#ML_BSSN::gt22_bound_limit = 0.0
+#$bound$#ML_BSSN::gt22_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::gt32_bound       = "skip"
+#$bound$#ML_BSSN::gt32_bound_speed = 1.0
+#$bound$#ML_BSSN::gt32_bound_limit = 0.0
+#$bound$#ML_BSSN::gt32_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::gt33_bound       = "skip"
+#$bound$#ML_BSSN::gt33_bound_speed = 1.0
+#$bound$#ML_BSSN::gt33_bound_limit = 0.0
+#$bound$#ML_BSSN::gt33_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::beta1_bound       = "skip"
+#$bound$#ML_BSSN::beta1_bound_speed = 1.0
+#$bound$#ML_BSSN::beta1_bound_limit = 0.0
+#$bound$#ML_BSSN::beta1_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::beta2_bound       = "skip"
+#$bound$#ML_BSSN::beta2_bound_speed = 1.0
+#$bound$#ML_BSSN::beta2_bound_limit = 0.0
+#$bound$#ML_BSSN::beta2_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::beta3_bound       = "skip"
+#$bound$#ML_BSSN::beta3_bound_speed = 1.0
+#$bound$#ML_BSSN::beta3_bound_limit = 0.0
+#$bound$#ML_BSSN::beta3_bound_scalar = 0.0
+
+#$bound$#ML_BSSN::trK_bound       = "skip"
+#$bound$#ML_BSSN::trK_bound_speed = 1.0
+#$bound$#ML_BSSN::trK_bound_limit = 0.0
+#$bound$#ML_BSSN::trK_bound_scalar = 0.0
+
 */
 
diff --git a/ML_BSSN/src/ML_BSSN_RHS.c b/ML_BSSN/src/ML_BSSN_RHS.c
new file mode 100644
index 0000000..930a860
--- /dev/null
+++ b/ML_BSSN/src/ML_BSSN_RHS.c
@@ -0,0 +1,1509 @@
+/*  File produced by user eschnett */
+/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
+
+/*  Mathematica script written by Ian Hinder and Sascha Husa */
+
+#define KRANC_C
+
+#include <math.h>
+#include "cctk.h"
+#include "cctk_Arguments.h"
+#include "cctk_Parameters.h"
+#include "GenericFD.h"
+#include "Differencing.h"
+#include "loopcontrol.h"
+
+/* Define macros used in calculations */
+#define INITVALUE  (42)
+#define INV(x) ((1.0) / (x))
+#define SQR(x) ((x) * (x))
+#define CUB(x) ((x) * (x) * (x))
+#define QAD(x) ((x) * (x) * (x) * (x))
+
+void ML_BSSN_RHS_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
+{
+  DECLARE_CCTK_ARGUMENTS
+  DECLARE_CCTK_PARAMETERS
+  
+  
+  /* Declare finite differencing variables */
+  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
+  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
+  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
+  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
+  
+  
+  /* Declare predefined quantities */
+  CCTK_REAL p1o12dx = INITVALUE;
+  CCTK_REAL p1o12dy = INITVALUE;
+  CCTK_REAL p1o12dz = INITVALUE;
+  CCTK_REAL p1o144dxdy = INITVALUE;
+  CCTK_REAL p1o144dxdz = INITVALUE;
+  CCTK_REAL p1o144dydz = INITVALUE;
+  CCTK_REAL pm1o12dx2 = INITVALUE;
+  CCTK_REAL pm1o12dy2 = INITVALUE;
+  CCTK_REAL pm1o12dz2 = INITVALUE;
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_BSSN_RHS_Body");
+  }
+  
+  if (cctk_iteration % ML_BSSN_RHS_calc_every != ML_BSSN_RHS_calc_offset)
+  {
+    return;
+  }
+  
+  /* Include user-supplied include files */
+  
+  /* Initialise finite differencing variables */
+  dx = CCTK_DELTA_SPACE(0);
+  dy = CCTK_DELTA_SPACE(1);
+  dz = CCTK_DELTA_SPACE(2);
+  dxi = 1.0 / dx;
+  dyi = 1.0 / dy;
+  dzi = 1.0 / dz;
+  khalf = 0.5;
+  kthird = 1/3.0;
+  ktwothird = 2.0/3.0;
+  kfourthird = 4.0/3.0;
+  keightthird = 8.0/3.0;
+  hdxi = 0.5 * dxi;
+  hdyi = 0.5 * dyi;
+  hdzi = 0.5 * dzi;
+  
+  /* Initialize predefined quantities */
+  p1o12dx = INV(dx)/12.;
+  p1o12dy = INV(dy)/12.;
+  p1o12dz = INV(dz)/12.;
+  p1o144dxdy = (INV(dx)*INV(dy))/144.;
+  p1o144dxdz = (INV(dx)*INV(dz))/144.;
+  p1o144dydz = (INV(dy)*INV(dz))/144.;
+  pm1o12dx2 = -pow(dx,-2)/12.;
+  pm1o12dy2 = -pow(dy,-2)/12.;
+  pm1o12dz2 = -pow(dz,-2)/12.;
+  
+  /* Loop over the grid points */
+  LC_LOOP3 (somename,
+            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
+            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+  {
+    int index = INITVALUE;
+    int subblock_index = INITVALUE;
+    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
+    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
+    
+    /* Declare shorthands */
+    CCTK_REAL Atm11 = INITVALUE, Atm12 = INITVALUE, Atm13 = INITVALUE, Atm21 = INITVALUE, Atm22 = INITVALUE, Atm23 = INITVALUE;
+    CCTK_REAL Atm31 = INITVALUE, Atm32 = INITVALUE, Atm33 = INITVALUE;
+    CCTK_REAL Atu11 = INITVALUE, Atu12 = INITVALUE, Atu13 = INITVALUE, Atu22 = INITVALUE, Atu23 = INITVALUE, Atu33 = INITVALUE;
+    CCTK_REAL ddetg1 = INITVALUE, ddetg2 = INITVALUE, ddetg3 = INITVALUE;
+    CCTK_REAL ddetgt1 = INITVALUE, ddetgt2 = INITVALUE, ddetgt3 = INITVALUE;
+    CCTK_REAL ddgtu1111 = INITVALUE, ddgtu1121 = INITVALUE, ddgtu1131 = INITVALUE, ddgtu1211 = INITVALUE, ddgtu1221 = INITVALUE, ddgtu1222 = INITVALUE;
+    CCTK_REAL ddgtu1231 = INITVALUE, ddgtu1232 = INITVALUE, ddgtu1311 = INITVALUE, ddgtu1321 = INITVALUE, ddgtu1331 = INITVALUE, ddgtu1332 = INITVALUE;
+    CCTK_REAL ddgtu1333 = INITVALUE, ddgtu2221 = INITVALUE, ddgtu2222 = INITVALUE, ddgtu2232 = INITVALUE, ddgtu2321 = INITVALUE, ddgtu2322 = INITVALUE;
+    CCTK_REAL ddgtu2331 = INITVALUE, ddgtu2332 = INITVALUE, ddgtu2333 = INITVALUE, ddgtu3331 = INITVALUE, ddgtu3332 = INITVALUE, ddgtu3333 = INITVALUE;
+    CCTK_REAL detg = INITVALUE;
+    CCTK_REAL detgt = INITVALUE;
+    CCTK_REAL dgtu111 = INITVALUE, dgtu112 = INITVALUE, dgtu113 = INITVALUE, dgtu121 = INITVALUE, dgtu122 = INITVALUE, dgtu123 = INITVALUE;
+    CCTK_REAL dgtu131 = INITVALUE, dgtu132 = INITVALUE, dgtu133 = INITVALUE, dgtu221 = INITVALUE, dgtu222 = INITVALUE, dgtu223 = INITVALUE;
+    CCTK_REAL dgtu231 = INITVALUE, dgtu232 = INITVALUE, dgtu233 = INITVALUE, dgtu331 = INITVALUE, dgtu332 = INITVALUE, dgtu333 = INITVALUE;
+    CCTK_REAL e4phi = INITVALUE;
+    CCTK_REAL em4phi = INITVALUE;
+    CCTK_REAL g11 = INITVALUE;
+    CCTK_REAL G111 = INITVALUE, G121 = INITVALUE, G122 = INITVALUE, G131 = INITVALUE, G132 = INITVALUE, G133 = INITVALUE;
+    CCTK_REAL g21 = INITVALUE;
+    CCTK_REAL G211 = INITVALUE;
+    CCTK_REAL g22 = INITVALUE;
+    CCTK_REAL G221 = INITVALUE, G222 = INITVALUE, G231 = INITVALUE, G232 = INITVALUE, G233 = INITVALUE;
+    CCTK_REAL g31 = INITVALUE;
+    CCTK_REAL G311 = INITVALUE;
+    CCTK_REAL g32 = INITVALUE;
+    CCTK_REAL G321 = INITVALUE, G322 = INITVALUE;
+    CCTK_REAL g33 = INITVALUE;
+    CCTK_REAL G331 = INITVALUE, G332 = INITVALUE, G333 = INITVALUE;
+    CCTK_REAL Gt111 = INITVALUE, Gt121 = INITVALUE, Gt122 = INITVALUE, Gt131 = INITVALUE, Gt132 = INITVALUE, Gt133 = INITVALUE;
+    CCTK_REAL Gt211 = INITVALUE, Gt221 = INITVALUE, Gt222 = INITVALUE, Gt231 = INITVALUE, Gt232 = INITVALUE, Gt233 = INITVALUE;
+    CCTK_REAL Gt311 = INITVALUE, Gt321 = INITVALUE, Gt322 = INITVALUE, Gt331 = INITVALUE, Gt332 = INITVALUE, Gt333 = INITVALUE;
+    CCTK_REAL gtu11 = INITVALUE, gtu12 = INITVALUE, gtu13 = INITVALUE, gtu22 = INITVALUE, gtu23 = INITVALUE, gtu33 = INITVALUE;
+    CCTK_REAL gu11 = INITVALUE, gu12 = INITVALUE, gu13 = INITVALUE, gu22 = INITVALUE, gu23 = INITVALUE, gu33 = INITVALUE;
+    CCTK_REAL R11 = INITVALUE, R21 = INITVALUE, R22 = INITVALUE, R31 = INITVALUE, R32 = INITVALUE, R33 = INITVALUE;
+    CCTK_REAL Rphi11 = INITVALUE, Rphi21 = INITVALUE, Rphi22 = INITVALUE, Rphi31 = INITVALUE, Rphi32 = INITVALUE, Rphi33 = INITVALUE;
+    CCTK_REAL Rt11 = INITVALUE, Rt21 = INITVALUE, Rt22 = INITVALUE, Rt31 = INITVALUE, Rt32 = INITVALUE, Rt33 = INITVALUE;
+    
+    /* Declare local copies of grid functions */
+    CCTK_REAL alphaL = INITVALUE, alpharhsL = INITVALUE;
+    CCTK_REAL At11L = INITVALUE, At11rhsL = INITVALUE, At21L = INITVALUE, At21rhsL = INITVALUE, At22L = INITVALUE, At22rhsL = INITVALUE;
+    CCTK_REAL At31L = INITVALUE, At31rhsL = INITVALUE, At32L = INITVALUE, At32rhsL = INITVALUE, At33L = INITVALUE, At33rhsL = INITVALUE;
+    CCTK_REAL beta1L = INITVALUE, beta1rhsL = INITVALUE, beta2L = INITVALUE, beta2rhsL = INITVALUE, beta3L = INITVALUE, beta3rhsL = INITVALUE;
+    CCTK_REAL dtalphaL = INITVALUE, dtalpharhsL = INITVALUE;
+    CCTK_REAL dtbeta1L = INITVALUE, dtbeta1rhsL = INITVALUE, dtbeta2L = INITVALUE, dtbeta2rhsL = INITVALUE, dtbeta3L = INITVALUE, dtbeta3rhsL = INITVALUE;
+    CCTK_REAL gt11L = INITVALUE, gt11rhsL = INITVALUE, gt21L = INITVALUE, gt21rhsL = INITVALUE, gt22L = INITVALUE, gt22rhsL = INITVALUE;
+    CCTK_REAL gt31L = INITVALUE, gt31rhsL = INITVALUE, gt32L = INITVALUE, gt32rhsL = INITVALUE, gt33L = INITVALUE, gt33rhsL = INITVALUE;
+    CCTK_REAL phiL = INITVALUE, phirhsL = INITVALUE;
+    CCTK_REAL trKL = INITVALUE, trKrhsL = INITVALUE;
+    CCTK_REAL Xt1L = INITVALUE, Xt1rhsL = INITVALUE, Xt2L = INITVALUE, Xt2rhsL = INITVALUE, Xt3L = INITVALUE, Xt3rhsL = INITVALUE;
+    /* Declare precomputed derivatives*/
+    
+    /* Declare derivatives */
+    CCTK_REAL PDstandard4th1alpha = INITVALUE;
+    CCTK_REAL PDstandard4th2alpha = INITVALUE;
+    CCTK_REAL PDstandard4th3alpha = INITVALUE;
+    CCTK_REAL PDstandard4th11alpha = INITVALUE;
+    CCTK_REAL PDstandard4th22alpha = INITVALUE;
+    CCTK_REAL PDstandard4th33alpha = INITVALUE;
+    CCTK_REAL PDstandard4th12alpha = INITVALUE;
+    CCTK_REAL PDstandard4th13alpha = INITVALUE;
+    CCTK_REAL PDstandard4th21alpha = INITVALUE;
+    CCTK_REAL PDstandard4th23alpha = INITVALUE;
+    CCTK_REAL PDstandard4th31alpha = INITVALUE;
+    CCTK_REAL PDstandard4th32alpha = INITVALUE;
+    CCTK_REAL PDstandard4th1At11 = INITVALUE;
+    CCTK_REAL PDstandard4th2At11 = INITVALUE;
+    CCTK_REAL PDstandard4th3At11 = INITVALUE;
+    CCTK_REAL PDstandard4th1At21 = INITVALUE;
+    CCTK_REAL PDstandard4th2At21 = INITVALUE;
+    CCTK_REAL PDstandard4th3At21 = INITVALUE;
+    CCTK_REAL PDstandard4th1At22 = INITVALUE;
+    CCTK_REAL PDstandard4th2At22 = INITVALUE;
+    CCTK_REAL PDstandard4th3At22 = INITVALUE;
+    CCTK_REAL PDstandard4th1At31 = INITVALUE;
+    CCTK_REAL PDstandard4th2At31 = INITVALUE;
+    CCTK_REAL PDstandard4th3At31 = INITVALUE;
+    CCTK_REAL PDstandard4th1At32 = INITVALUE;
+    CCTK_REAL PDstandard4th2At32 = INITVALUE;
+    CCTK_REAL PDstandard4th3At32 = INITVALUE;
+    CCTK_REAL PDstandard4th1At33 = INITVALUE;
+    CCTK_REAL PDstandard4th2At33 = INITVALUE;
+    CCTK_REAL PDstandard4th3At33 = INITVALUE;
+    CCTK_REAL PDstandard4th1beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th2beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th3beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th11beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th22beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th33beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th12beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th13beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th21beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th23beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th31beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th32beta1 = INITVALUE;
+    CCTK_REAL PDstandard4th1beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th2beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th3beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th11beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th22beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th33beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th12beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th13beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th21beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th23beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th31beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th32beta2 = INITVALUE;
+    CCTK_REAL PDstandard4th1beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th2beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th3beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th11beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th22beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th33beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th12beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th13beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th21beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th23beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th31beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th32beta3 = INITVALUE;
+    CCTK_REAL PDstandard4th1dtalpha = INITVALUE;
+    CCTK_REAL PDstandard4th2dtalpha = INITVALUE;
+    CCTK_REAL PDstandard4th3dtalpha = INITVALUE;
+    CCTK_REAL PDstandard4th1dtbeta1 = INITVALUE;
+    CCTK_REAL PDstandard4th2dtbeta1 = INITVALUE;
+    CCTK_REAL PDstandard4th3dtbeta1 = INITVALUE;
+    CCTK_REAL PDstandard4th1dtbeta2 = INITVALUE;
+    CCTK_REAL PDstandard4th2dtbeta2 = INITVALUE;
+    CCTK_REAL PDstandard4th3dtbeta2 = INITVALUE;
+    CCTK_REAL PDstandard4th1dtbeta3 = INITVALUE;
+    CCTK_REAL PDstandard4th2dtbeta3 = INITVALUE;
+    CCTK_REAL PDstandard4th3dtbeta3 = INITVALUE;
+    CCTK_REAL PDstandard4th1gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th2gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th3gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th11gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th22gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th33gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th12gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th13gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th21gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th23gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th31gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th32gt11 = INITVALUE;
+    CCTK_REAL PDstandard4th1gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th2gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th3gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th11gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th22gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th33gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th12gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th13gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th21gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th23gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th31gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th32gt21 = INITVALUE;
+    CCTK_REAL PDstandard4th1gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th2gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th3gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th11gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th22gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th33gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th12gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th13gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th21gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th23gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th31gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th32gt22 = INITVALUE;
+    CCTK_REAL PDstandard4th1gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th2gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th3gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th11gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th22gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th33gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th12gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th13gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th21gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th23gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th31gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th32gt31 = INITVALUE;
+    CCTK_REAL PDstandard4th1gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th2gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th3gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th11gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th22gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th33gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th12gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th13gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th21gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th23gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th31gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th32gt32 = INITVALUE;
+    CCTK_REAL PDstandard4th1gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th2gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th3gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th11gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th22gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th33gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th12gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th13gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th21gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th23gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th31gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th32gt33 = INITVALUE;
+    CCTK_REAL PDstandard4th1phi = INITVALUE;
+    CCTK_REAL PDstandard4th2phi = INITVALUE;
+    CCTK_REAL PDstandard4th3phi = INITVALUE;
+    CCTK_REAL PDstandard4th11phi = INITVALUE;
+    CCTK_REAL PDstandard4th22phi = INITVALUE;
+    CCTK_REAL PDstandard4th33phi = INITVALUE;
+    CCTK_REAL PDstandard4th12phi = INITVALUE;
+    CCTK_REAL PDstandard4th13phi = INITVALUE;
+    CCTK_REAL PDstandard4th21phi = INITVALUE;
+    CCTK_REAL PDstandard4th23phi = INITVALUE;
+    CCTK_REAL PDstandard4th31phi = INITVALUE;
+    CCTK_REAL PDstandard4th32phi = INITVALUE;
+    CCTK_REAL PDstandard4th1trK = INITVALUE;
+    CCTK_REAL PDstandard4th2trK = INITVALUE;
+    CCTK_REAL PDstandard4th3trK = INITVALUE;
+    CCTK_REAL PDstandard4th1Xt1 = INITVALUE;
+    CCTK_REAL PDstandard4th2Xt1 = INITVALUE;
+    CCTK_REAL PDstandard4th3Xt1 = INITVALUE;
+    CCTK_REAL PDstandard4th1Xt2 = INITVALUE;
+    CCTK_REAL PDstandard4th2Xt2 = INITVALUE;
+    CCTK_REAL PDstandard4th3Xt2 = INITVALUE;
+    CCTK_REAL PDstandard4th1Xt3 = INITVALUE;
+    CCTK_REAL PDstandard4th2Xt3 = INITVALUE;
+    CCTK_REAL PDstandard4th3Xt3 = INITVALUE;
+    
+    /* Assign local copies of grid functions */
+    alphaL = alpha[index];
+    At11L = At11[index];
+    At21L = At21[index];
+    At22L = At22[index];
+    At31L = At31[index];
+    At32L = At32[index];
+    At33L = At33[index];
+    beta1L = beta1[index];
+    beta2L = beta2[index];
+    beta3L = beta3[index];
+    dtalphaL = dtalpha[index];
+    dtbeta1L = dtbeta1[index];
+    dtbeta2L = dtbeta2[index];
+    dtbeta3L = dtbeta3[index];
+    gt11L = gt11[index];
+    gt21L = gt21[index];
+    gt22L = gt22[index];
+    gt31L = gt31[index];
+    gt32L = gt32[index];
+    gt33L = gt33[index];
+    phiL = phi[index];
+    trKL = trK[index];
+    Xt1L = Xt1[index];
+    Xt2L = Xt2[index];
+    Xt3L = Xt3[index];
+    
+    /* Assign local copies of subblock grid functions */
+    
+    /* Include user supplied include files */
+    
+    /* Precompute derivatives (new style) */
+    PDstandard4th1alpha = PDstandard4th1(alpha, i, j, k);
+    PDstandard4th2alpha = PDstandard4th2(alpha, i, j, k);
+    PDstandard4th3alpha = PDstandard4th3(alpha, i, j, k);
+    PDstandard4th11alpha = PDstandard4th11(alpha, i, j, k);
+    PDstandard4th22alpha = PDstandard4th22(alpha, i, j, k);
+    PDstandard4th33alpha = PDstandard4th33(alpha, i, j, k);
+    PDstandard4th12alpha = PDstandard4th12(alpha, i, j, k);
+    PDstandard4th13alpha = PDstandard4th13(alpha, i, j, k);
+    PDstandard4th23alpha = PDstandard4th23(alpha, i, j, k);
+    PDstandard4th1At11 = PDstandard4th1(At11, i, j, k);
+    PDstandard4th2At11 = PDstandard4th2(At11, i, j, k);
+    PDstandard4th3At11 = PDstandard4th3(At11, i, j, k);
+    PDstandard4th1At21 = PDstandard4th1(At21, i, j, k);
+    PDstandard4th2At21 = PDstandard4th2(At21, i, j, k);
+    PDstandard4th3At21 = PDstandard4th3(At21, i, j, k);
+    PDstandard4th1At22 = PDstandard4th1(At22, i, j, k);
+    PDstandard4th2At22 = PDstandard4th2(At22, i, j, k);
+    PDstandard4th3At22 = PDstandard4th3(At22, i, j, k);
+    PDstandard4th1At31 = PDstandard4th1(At31, i, j, k);
+    PDstandard4th2At31 = PDstandard4th2(At31, i, j, k);
+    PDstandard4th3At31 = PDstandard4th3(At31, i, j, k);
+    PDstandard4th1At32 = PDstandard4th1(At32, i, j, k);
+    PDstandard4th2At32 = PDstandard4th2(At32, i, j, k);
+    PDstandard4th3At32 = PDstandard4th3(At32, i, j, k);
+    PDstandard4th1At33 = PDstandard4th1(At33, i, j, k);
+    PDstandard4th2At33 = PDstandard4th2(At33, i, j, k);
+    PDstandard4th3At33 = PDstandard4th3(At33, i, j, k);
+    PDstandard4th1beta1 = PDstandard4th1(beta1, i, j, k);
+    PDstandard4th2beta1 = PDstandard4th2(beta1, i, j, k);
+    PDstandard4th3beta1 = PDstandard4th3(beta1, i, j, k);
+    PDstandard4th11beta1 = PDstandard4th11(beta1, i, j, k);
+    PDstandard4th22beta1 = PDstandard4th22(beta1, i, j, k);
+    PDstandard4th33beta1 = PDstandard4th33(beta1, i, j, k);
+    PDstandard4th12beta1 = PDstandard4th12(beta1, i, j, k);
+    PDstandard4th13beta1 = PDstandard4th13(beta1, i, j, k);
+    PDstandard4th23beta1 = PDstandard4th23(beta1, i, j, k);
+    PDstandard4th1beta2 = PDstandard4th1(beta2, i, j, k);
+    PDstandard4th2beta2 = PDstandard4th2(beta2, i, j, k);
+    PDstandard4th3beta2 = PDstandard4th3(beta2, i, j, k);
+    PDstandard4th11beta2 = PDstandard4th11(beta2, i, j, k);
+    PDstandard4th22beta2 = PDstandard4th22(beta2, i, j, k);
+    PDstandard4th33beta2 = PDstandard4th33(beta2, i, j, k);
+    PDstandard4th12beta2 = PDstandard4th12(beta2, i, j, k);
+    PDstandard4th13beta2 = PDstandard4th13(beta2, i, j, k);
+    PDstandard4th23beta2 = PDstandard4th23(beta2, i, j, k);
+    PDstandard4th1beta3 = PDstandard4th1(beta3, i, j, k);
+    PDstandard4th2beta3 = PDstandard4th2(beta3, i, j, k);
+    PDstandard4th3beta3 = PDstandard4th3(beta3, i, j, k);
+    PDstandard4th11beta3 = PDstandard4th11(beta3, i, j, k);
+    PDstandard4th22beta3 = PDstandard4th22(beta3, i, j, k);
+    PDstandard4th33beta3 = PDstandard4th33(beta3, i, j, k);
+    PDstandard4th12beta3 = PDstandard4th12(beta3, i, j, k);
+    PDstandard4th13beta3 = PDstandard4th13(beta3, i, j, k);
+    PDstandard4th23beta3 = PDstandard4th23(beta3, i, j, k);
+    PDstandard4th1dtalpha = PDstandard4th1(dtalpha, i, j, k);
+    PDstandard4th2dtalpha = PDstandard4th2(dtalpha, i, j, k);
+    PDstandard4th3dtalpha = PDstandard4th3(dtalpha, i, j, k);
+    PDstandard4th1dtbeta1 = PDstandard4th1(dtbeta1, i, j, k);
+    PDstandard4th2dtbeta1 = PDstandard4th2(dtbeta1, i, j, k);
+    PDstandard4th3dtbeta1 = PDstandard4th3(dtbeta1, i, j, k);
+    PDstandard4th1dtbeta2 = PDstandard4th1(dtbeta2, i, j, k);
+    PDstandard4th2dtbeta2 = PDstandard4th2(dtbeta2, i, j, k);
+    PDstandard4th3dtbeta2 = PDstandard4th3(dtbeta2, i, j, k);
+    PDstandard4th1dtbeta3 = PDstandard4th1(dtbeta3, i, j, k);
+    PDstandard4th2dtbeta3 = PDstandard4th2(dtbeta3, i, j, k);
+    PDstandard4th3dtbeta3 = PDstandard4th3(dtbeta3, i, j, k);
+    PDstandard4th1gt11 = PDstandard4th1(gt11, i, j, k);
+    PDstandard4th2gt11 = PDstandard4th2(gt11, i, j, k);
+    PDstandard4th3gt11 = PDstandard4th3(gt11, i, j, k);
+    PDstandard4th11gt11 = PDstandard4th11(gt11, i, j, k);
+    PDstandard4th22gt11 = PDstandard4th22(gt11, i, j, k);
+    PDstandard4th33gt11 = PDstandard4th33(gt11, i, j, k);
+    PDstandard4th12gt11 = PDstandard4th12(gt11, i, j, k);
+    PDstandard4th13gt11 = PDstandard4th13(gt11, i, j, k);
+    PDstandard4th23gt11 = PDstandard4th23(gt11, i, j, k);
+    PDstandard4th1gt21 = PDstandard4th1(gt21, i, j, k);
+    PDstandard4th2gt21 = PDstandard4th2(gt21, i, j, k);
+    PDstandard4th3gt21 = PDstandard4th3(gt21, i, j, k);
+    PDstandard4th11gt21 = PDstandard4th11(gt21, i, j, k);
+    PDstandard4th22gt21 = PDstandard4th22(gt21, i, j, k);
+    PDstandard4th33gt21 = PDstandard4th33(gt21, i, j, k);
+    PDstandard4th12gt21 = PDstandard4th12(gt21, i, j, k);
+    PDstandard4th13gt21 = PDstandard4th13(gt21, i, j, k);
+    PDstandard4th23gt21 = PDstandard4th23(gt21, i, j, k);
+    PDstandard4th1gt22 = PDstandard4th1(gt22, i, j, k);
+    PDstandard4th2gt22 = PDstandard4th2(gt22, i, j, k);
+    PDstandard4th3gt22 = PDstandard4th3(gt22, i, j, k);
+    PDstandard4th11gt22 = PDstandard4th11(gt22, i, j, k);
+    PDstandard4th22gt22 = PDstandard4th22(gt22, i, j, k);
+    PDstandard4th33gt22 = PDstandard4th33(gt22, i, j, k);
+    PDstandard4th12gt22 = PDstandard4th12(gt22, i, j, k);
+    PDstandard4th13gt22 = PDstandard4th13(gt22, i, j, k);
+    PDstandard4th23gt22 = PDstandard4th23(gt22, i, j, k);
+    PDstandard4th1gt31 = PDstandard4th1(gt31, i, j, k);
+    PDstandard4th2gt31 = PDstandard4th2(gt31, i, j, k);
+    PDstandard4th3gt31 = PDstandard4th3(gt31, i, j, k);
+    PDstandard4th11gt31 = PDstandard4th11(gt31, i, j, k);
+    PDstandard4th22gt31 = PDstandard4th22(gt31, i, j, k);
+    PDstandard4th33gt31 = PDstandard4th33(gt31, i, j, k);
+    PDstandard4th12gt31 = PDstandard4th12(gt31, i, j, k);
+    PDstandard4th13gt31 = PDstandard4th13(gt31, i, j, k);
+    PDstandard4th23gt31 = PDstandard4th23(gt31, i, j, k);
+    PDstandard4th1gt32 = PDstandard4th1(gt32, i, j, k);
+    PDstandard4th2gt32 = PDstandard4th2(gt32, i, j, k);
+    PDstandard4th3gt32 = PDstandard4th3(gt32, i, j, k);
+    PDstandard4th11gt32 = PDstandard4th11(gt32, i, j, k);
+    PDstandard4th22gt32 = PDstandard4th22(gt32, i, j, k);
+    PDstandard4th33gt32 = PDstandard4th33(gt32, i, j, k);
+    PDstandard4th12gt32 = PDstandard4th12(gt32, i, j, k);
+    PDstandard4th13gt32 = PDstandard4th13(gt32, i, j, k);
+    PDstandard4th23gt32 = PDstandard4th23(gt32, i, j, k);
+    PDstandard4th1gt33 = PDstandard4th1(gt33, i, j, k);
+    PDstandard4th2gt33 = PDstandard4th2(gt33, i, j, k);
+    PDstandard4th3gt33 = PDstandard4th3(gt33, i, j, k);
+    PDstandard4th11gt33 = PDstandard4th11(gt33, i, j, k);
+    PDstandard4th22gt33 = PDstandard4th22(gt33, i, j, k);
+    PDstandard4th33gt33 = PDstandard4th33(gt33, i, j, k);
+    PDstandard4th12gt33 = PDstandard4th12(gt33, i, j, k);
+    PDstandard4th13gt33 = PDstandard4th13(gt33, i, j, k);
+    PDstandard4th23gt33 = PDstandard4th23(gt33, i, j, k);
+    PDstandard4th1phi = PDstandard4th1(phi, i, j, k);
+    PDstandard4th2phi = PDstandard4th2(phi, i, j, k);
+    PDstandard4th3phi = PDstandard4th3(phi, i, j, k);
+    PDstandard4th11phi = PDstandard4th11(phi, i, j, k);
+    PDstandard4th22phi = PDstandard4th22(phi, i, j, k);
+    PDstandard4th33phi = PDstandard4th33(phi, i, j, k);
+    PDstandard4th12phi = PDstandard4th12(phi, i, j, k);
+    PDstandard4th13phi = PDstandard4th13(phi, i, j, k);
+    PDstandard4th23phi = PDstandard4th23(phi, i, j, k);
+    PDstandard4th1trK = PDstandard4th1(trK, i, j, k);
+    PDstandard4th2trK = PDstandard4th2(trK, i, j, k);
+    PDstandard4th3trK = PDstandard4th3(trK, i, j, k);
+    PDstandard4th1Xt1 = PDstandard4th1(Xt1, i, j, k);
+    PDstandard4th2Xt1 = PDstandard4th2(Xt1, i, j, k);
+    PDstandard4th3Xt1 = PDstandard4th3(Xt1, i, j, k);
+    PDstandard4th1Xt2 = PDstandard4th1(Xt2, i, j, k);
+    PDstandard4th2Xt2 = PDstandard4th2(Xt2, i, j, k);
+    PDstandard4th3Xt2 = PDstandard4th3(Xt2, i, j, k);
+    PDstandard4th1Xt3 = PDstandard4th1(Xt3, i, j, k);
+    PDstandard4th2Xt3 = PDstandard4th2(Xt3, i, j, k);
+    PDstandard4th3Xt3 = PDstandard4th3(Xt3, i, j, k);
+    
+    /* Precompute derivatives (old style) */
+    
+    /* Calculate temporaries and grid functions */
+    detgt  =  1;
+    
+    ddetgt1  =  0;
+    
+    ddetgt2  =  0;
+    
+    ddetgt3  =  0;
+    
+    gtu11  =  INV(detgt)*(gt22L*gt33L - SQR(gt32L));
+    
+    gtu12  =  (gt31L*gt32L - gt21L*gt33L)*INV(detgt);
+    
+    gtu13  =  (-(gt22L*gt31L) + gt21L*gt32L)*INV(detgt);
+    
+    gtu22  =  INV(detgt)*(gt11L*gt33L - SQR(gt31L));
+    
+    gtu23  =  (gt21L*gt31L - gt11L*gt32L)*INV(detgt);
+    
+    gtu33  =  INV(detgt)*(gt11L*gt22L - SQR(gt21L));
+    
+    dgtu111  =  -2*(gtu11*gtu12*PDstandard4th1gt21 + gtu11*gtu13*PDstandard4th1gt31 + gtu12*gtu13*PDstandard4th1gt32) - 
+        PDstandard4th1gt11*SQR(gtu11) - PDstandard4th1gt22*SQR(gtu12) - PDstandard4th1gt33*SQR(gtu13);
+    
+    dgtu121  =  -(gtu11*gtu12*PDstandard4th1gt11) - gtu11*gtu22*PDstandard4th1gt21 - gtu12*gtu22*PDstandard4th1gt22 - 
+        gtu12*gtu13*PDstandard4th1gt31 - gtu11*gtu23*PDstandard4th1gt31 - gtu13*gtu22*PDstandard4th1gt32 - 
+        gtu12*gtu23*PDstandard4th1gt32 - gtu13*gtu23*PDstandard4th1gt33 - PDstandard4th1gt21*SQR(gtu12);
+    
+    dgtu131  =  -(gtu11*gtu13*PDstandard4th1gt11) - gtu12*gtu13*PDstandard4th1gt21 - gtu11*gtu23*PDstandard4th1gt21 - 
+        gtu12*gtu23*PDstandard4th1gt22 - gtu11*gtu33*PDstandard4th1gt31 - gtu13*gtu23*PDstandard4th1gt32 - 
+        gtu12*gtu33*PDstandard4th1gt32 - gtu13*gtu33*PDstandard4th1gt33 - PDstandard4th1gt31*SQR(gtu13);
+    
+    dgtu221  =  -2*(gtu12*gtu22*PDstandard4th1gt21 + gtu12*gtu23*PDstandard4th1gt31 + gtu22*gtu23*PDstandard4th1gt32) - 
+        PDstandard4th1gt11*SQR(gtu12) - PDstandard4th1gt22*SQR(gtu22) - PDstandard4th1gt33*SQR(gtu23);
+    
+    dgtu231  =  -(gtu12*gtu13*PDstandard4th1gt11) - gtu13*gtu22*PDstandard4th1gt21 - gtu12*gtu23*PDstandard4th1gt21 - 
+        gtu22*gtu23*PDstandard4th1gt22 - gtu13*gtu23*PDstandard4th1gt31 - gtu12*gtu33*PDstandard4th1gt31 - 
+        gtu22*gtu33*PDstandard4th1gt32 - gtu23*gtu33*PDstandard4th1gt33 - PDstandard4th1gt32*SQR(gtu23);
+    
+    dgtu331  =  -2*(gtu13*gtu23*PDstandard4th1gt21 + gtu13*gtu33*PDstandard4th1gt31 + gtu23*gtu33*PDstandard4th1gt32) - 
+        PDstandard4th1gt11*SQR(gtu13) - PDstandard4th1gt22*SQR(gtu23) - PDstandard4th1gt33*SQR(gtu33);
+    
+    dgtu112  =  -2*(gtu11*gtu12*PDstandard4th2gt21 + gtu11*gtu13*PDstandard4th2gt31 + gtu12*gtu13*PDstandard4th2gt32) - 
+        PDstandard4th2gt11*SQR(gtu11) - PDstandard4th2gt22*SQR(gtu12) - PDstandard4th2gt33*SQR(gtu13);
+    
+    dgtu122  =  -(gtu11*gtu12*PDstandard4th2gt11) - gtu11*gtu22*PDstandard4th2gt21 - gtu12*gtu22*PDstandard4th2gt22 - 
+        gtu12*gtu13*PDstandard4th2gt31 - gtu11*gtu23*PDstandard4th2gt31 - gtu13*gtu22*PDstandard4th2gt32 - 
+        gtu12*gtu23*PDstandard4th2gt32 - gtu13*gtu23*PDstandard4th2gt33 - PDstandard4th2gt21*SQR(gtu12);
+    
+    dgtu132  =  -(gtu11*gtu13*PDstandard4th2gt11) - gtu12*gtu13*PDstandard4th2gt21 - gtu11*gtu23*PDstandard4th2gt21 - 
+        gtu12*gtu23*PDstandard4th2gt22 - gtu11*gtu33*PDstandard4th2gt31 - gtu13*gtu23*PDstandard4th2gt32 - 
+        gtu12*gtu33*PDstandard4th2gt32 - gtu13*gtu33*PDstandard4th2gt33 - PDstandard4th2gt31*SQR(gtu13);
+    
+    dgtu222  =  -2*(gtu12*gtu22*PDstandard4th2gt21 + gtu12*gtu23*PDstandard4th2gt31 + gtu22*gtu23*PDstandard4th2gt32) - 
+        PDstandard4th2gt11*SQR(gtu12) - PDstandard4th2gt22*SQR(gtu22) - PDstandard4th2gt33*SQR(gtu23);
+    
+    dgtu232  =  -(gtu12*gtu13*PDstandard4th2gt11) - gtu13*gtu22*PDstandard4th2gt21 - gtu12*gtu23*PDstandard4th2gt21 - 
+        gtu22*gtu23*PDstandard4th2gt22 - gtu13*gtu23*PDstandard4th2gt31 - gtu12*gtu33*PDstandard4th2gt31 - 
+        gtu22*gtu33*PDstandard4th2gt32 - gtu23*gtu33*PDstandard4th2gt33 - PDstandard4th2gt32*SQR(gtu23);
+    
+    dgtu332  =  -2*(gtu13*gtu23*PDstandard4th2gt21 + gtu13*gtu33*PDstandard4th2gt31 + gtu23*gtu33*PDstandard4th2gt32) - 
+        PDstandard4th2gt11*SQR(gtu13) - PDstandard4th2gt22*SQR(gtu23) - PDstandard4th2gt33*SQR(gtu33);
+    
+    dgtu113  =  -2*(gtu11*gtu12*PDstandard4th3gt21 + gtu11*gtu13*PDstandard4th3gt31 + gtu12*gtu13*PDstandard4th3gt32) - 
+        PDstandard4th3gt11*SQR(gtu11) - PDstandard4th3gt22*SQR(gtu12) - PDstandard4th3gt33*SQR(gtu13);
+    
+    dgtu123  =  -(gtu11*gtu12*PDstandard4th3gt11) - gtu11*gtu22*PDstandard4th3gt21 - gtu12*gtu22*PDstandard4th3gt22 - 
+        gtu12*gtu13*PDstandard4th3gt31 - gtu11*gtu23*PDstandard4th3gt31 - gtu13*gtu22*PDstandard4th3gt32 - 
+        gtu12*gtu23*PDstandard4th3gt32 - gtu13*gtu23*PDstandard4th3gt33 - PDstandard4th3gt21*SQR(gtu12);
+    
+    dgtu133  =  -(gtu11*gtu13*PDstandard4th3gt11) - gtu12*gtu13*PDstandard4th3gt21 - gtu11*gtu23*PDstandard4th3gt21 - 
+        gtu12*gtu23*PDstandard4th3gt22 - gtu11*gtu33*PDstandard4th3gt31 - gtu13*gtu23*PDstandard4th3gt32 - 
+        gtu12*gtu33*PDstandard4th3gt32 - gtu13*gtu33*PDstandard4th3gt33 - PDstandard4th3gt31*SQR(gtu13);
+    
+    dgtu223  =  -2*(gtu12*gtu22*PDstandard4th3gt21 + gtu12*gtu23*PDstandard4th3gt31 + gtu22*gtu23*PDstandard4th3gt32) - 
+        PDstandard4th3gt11*SQR(gtu12) - PDstandard4th3gt22*SQR(gtu22) - PDstandard4th3gt33*SQR(gtu23);
+    
+    dgtu233  =  -(gtu12*gtu13*PDstandard4th3gt11) - gtu13*gtu22*PDstandard4th3gt21 - gtu12*gtu23*PDstandard4th3gt21 - 
+        gtu22*gtu23*PDstandard4th3gt22 - gtu13*gtu23*PDstandard4th3gt31 - gtu12*gtu33*PDstandard4th3gt31 - 
+        gtu22*gtu33*PDstandard4th3gt32 - gtu23*gtu33*PDstandard4th3gt33 - PDstandard4th3gt32*SQR(gtu23);
+    
+    dgtu333  =  -2*(gtu13*gtu23*PDstandard4th3gt21 + gtu13*gtu33*PDstandard4th3gt31 + gtu23*gtu33*PDstandard4th3gt32) - 
+        PDstandard4th3gt11*SQR(gtu13) - PDstandard4th3gt22*SQR(gtu23) - PDstandard4th3gt33*SQR(gtu33);
+    
+    ddgtu1111  =  -2*(gtu11*gtu12*PDstandard4th11gt21 + gtu11*gtu13*PDstandard4th11gt31 + gtu12*gtu13*PDstandard4th11gt32 + 
+           dgtu111*gtu11*PDstandard4th1gt11 + dgtu121*gtu11*PDstandard4th1gt21 + dgtu111*gtu12*PDstandard4th1gt21 + 
+           dgtu121*gtu12*PDstandard4th1gt22 + dgtu131*gtu11*PDstandard4th1gt31 + dgtu111*gtu13*PDstandard4th1gt31 + 
+           dgtu131*gtu12*PDstandard4th1gt32 + dgtu121*gtu13*PDstandard4th1gt32 + dgtu131*gtu13*PDstandard4th1gt33) - 
+        PDstandard4th11gt11*SQR(gtu11) - PDstandard4th11gt22*SQR(gtu12) - PDstandard4th11gt33*SQR(gtu13);
+    
+    ddgtu1211  =  -(gtu11*gtu12*PDstandard4th11gt11) - gtu11*gtu22*PDstandard4th11gt21 - gtu12*gtu22*PDstandard4th11gt22 - 
+        gtu12*gtu13*PDstandard4th11gt31 - gtu11*gtu23*PDstandard4th11gt31 - gtu13*gtu22*PDstandard4th11gt32 - 
+        gtu12*gtu23*PDstandard4th11gt32 - gtu13*gtu23*PDstandard4th11gt33 - dgtu121*gtu11*PDstandard4th1gt11 - 
+        dgtu111*gtu12*PDstandard4th1gt11 - dgtu221*gtu11*PDstandard4th1gt21 - 2*dgtu121*gtu12*PDstandard4th1gt21 - 
+        dgtu111*gtu22*PDstandard4th1gt21 - dgtu221*gtu12*PDstandard4th1gt22 - dgtu121*gtu22*PDstandard4th1gt22 - 
+        dgtu231*gtu11*PDstandard4th1gt31 - dgtu131*gtu12*PDstandard4th1gt31 - dgtu121*gtu13*PDstandard4th1gt31 - 
+        dgtu111*gtu23*PDstandard4th1gt31 - dgtu231*gtu12*PDstandard4th1gt32 - dgtu221*gtu13*PDstandard4th1gt32 - 
+        dgtu131*gtu22*PDstandard4th1gt32 - dgtu121*gtu23*PDstandard4th1gt32 - dgtu231*gtu13*PDstandard4th1gt33 - 
+        dgtu131*gtu23*PDstandard4th1gt33 - PDstandard4th11gt21*SQR(gtu12);
+    
+    ddgtu1311  =  -(gtu11*gtu13*PDstandard4th11gt11) - gtu12*gtu13*PDstandard4th11gt21 - gtu11*gtu23*PDstandard4th11gt21 - 
+        gtu12*gtu23*PDstandard4th11gt22 - gtu11*gtu33*PDstandard4th11gt31 - gtu13*gtu23*PDstandard4th11gt32 - 
+        gtu12*gtu33*PDstandard4th11gt32 - gtu13*gtu33*PDstandard4th11gt33 - dgtu131*gtu11*PDstandard4th1gt11 - 
+        dgtu111*gtu13*PDstandard4th1gt11 - dgtu231*gtu11*PDstandard4th1gt21 - dgtu131*gtu12*PDstandard4th1gt21 - 
+        dgtu121*gtu13*PDstandard4th1gt21 - dgtu111*gtu23*PDstandard4th1gt21 - dgtu231*gtu12*PDstandard4th1gt22 - 
+        dgtu121*gtu23*PDstandard4th1gt22 - dgtu331*gtu11*PDstandard4th1gt31 - 2*dgtu131*gtu13*PDstandard4th1gt31 - 
+        dgtu111*gtu33*PDstandard4th1gt31 - dgtu331*gtu12*PDstandard4th1gt32 - dgtu231*gtu13*PDstandard4th1gt32 - 
+        dgtu131*gtu23*PDstandard4th1gt32 - dgtu121*gtu33*PDstandard4th1gt32 - dgtu331*gtu13*PDstandard4th1gt33 - 
+        dgtu131*gtu33*PDstandard4th1gt33 - PDstandard4th11gt31*SQR(gtu13);
+    
+    ddgtu1121  =  -2*(gtu11*gtu12*PDstandard4th12gt21 + gtu11*gtu13*PDstandard4th12gt31 + gtu12*gtu13*PDstandard4th12gt32 + 
+           dgtu112*gtu11*PDstandard4th1gt11 + dgtu122*gtu11*PDstandard4th1gt21 + dgtu112*gtu12*PDstandard4th1gt21 + 
+           dgtu122*gtu12*PDstandard4th1gt22 + dgtu132*gtu11*PDstandard4th1gt31 + dgtu112*gtu13*PDstandard4th1gt31 + 
+           dgtu132*gtu12*PDstandard4th1gt32 + dgtu122*gtu13*PDstandard4th1gt32 + dgtu132*gtu13*PDstandard4th1gt33) - 
+        PDstandard4th12gt11*SQR(gtu11) - PDstandard4th12gt22*SQR(gtu12) - PDstandard4th12gt33*SQR(gtu13);
+    
+    ddgtu1221  =  -(gtu11*gtu12*PDstandard4th12gt11) - gtu11*gtu22*PDstandard4th12gt21 - gtu12*gtu22*PDstandard4th12gt22 - 
+        gtu12*gtu13*PDstandard4th12gt31 - gtu11*gtu23*PDstandard4th12gt31 - gtu13*gtu22*PDstandard4th12gt32 - 
+        gtu12*gtu23*PDstandard4th12gt32 - gtu13*gtu23*PDstandard4th12gt33 - dgtu122*gtu11*PDstandard4th1gt11 - 
+        dgtu112*gtu12*PDstandard4th1gt11 - dgtu222*gtu11*PDstandard4th1gt21 - 2*dgtu122*gtu12*PDstandard4th1gt21 - 
+        dgtu112*gtu22*PDstandard4th1gt21 - dgtu222*gtu12*PDstandard4th1gt22 - dgtu122*gtu22*PDstandard4th1gt22 - 
+        dgtu232*gtu11*PDstandard4th1gt31 - dgtu132*gtu12*PDstandard4th1gt31 - dgtu122*gtu13*PDstandard4th1gt31 - 
+        dgtu112*gtu23*PDstandard4th1gt31 - dgtu232*gtu12*PDstandard4th1gt32 - dgtu222*gtu13*PDstandard4th1gt32 - 
+        dgtu132*gtu22*PDstandard4th1gt32 - dgtu122*gtu23*PDstandard4th1gt32 - dgtu232*gtu13*PDstandard4th1gt33 - 
+        dgtu132*gtu23*PDstandard4th1gt33 - PDstandard4th12gt21*SQR(gtu12);
+    
+    ddgtu1321  =  -(gtu11*gtu13*PDstandard4th12gt11) - gtu12*gtu13*PDstandard4th12gt21 - gtu11*gtu23*PDstandard4th12gt21 - 
+        gtu12*gtu23*PDstandard4th12gt22 - gtu11*gtu33*PDstandard4th12gt31 - gtu13*gtu23*PDstandard4th12gt32 - 
+        gtu12*gtu33*PDstandard4th12gt32 - gtu13*gtu33*PDstandard4th12gt33 - dgtu132*gtu11*PDstandard4th1gt11 - 
+        dgtu112*gtu13*PDstandard4th1gt11 - dgtu232*gtu11*PDstandard4th1gt21 - dgtu132*gtu12*PDstandard4th1gt21 - 
+        dgtu122*gtu13*PDstandard4th1gt21 - dgtu112*gtu23*PDstandard4th1gt21 - dgtu232*gtu12*PDstandard4th1gt22 - 
+        dgtu122*gtu23*PDstandard4th1gt22 - dgtu332*gtu11*PDstandard4th1gt31 - 2*dgtu132*gtu13*PDstandard4th1gt31 - 
+        dgtu112*gtu33*PDstandard4th1gt31 - dgtu332*gtu12*PDstandard4th1gt32 - dgtu232*gtu13*PDstandard4th1gt32 - 
+        dgtu132*gtu23*PDstandard4th1gt32 - dgtu122*gtu33*PDstandard4th1gt32 - dgtu332*gtu13*PDstandard4th1gt33 - 
+        dgtu132*gtu33*PDstandard4th1gt33 - PDstandard4th12gt31*SQR(gtu13);
+    
+    ddgtu2221  =  -2*(gtu12*gtu22*PDstandard4th12gt21 + gtu12*gtu23*PDstandard4th12gt31 + gtu22*gtu23*PDstandard4th12gt32 + 
+           dgtu122*gtu12*PDstandard4th1gt11 + dgtu222*gtu12*PDstandard4th1gt21 + dgtu122*gtu22*PDstandard4th1gt21 + 
+           dgtu222*gtu22*PDstandard4th1gt22 + dgtu232*gtu12*PDstandard4th1gt31 + dgtu122*gtu23*PDstandard4th1gt31 + 
+           dgtu232*gtu22*PDstandard4th1gt32 + dgtu222*gtu23*PDstandard4th1gt32 + dgtu232*gtu23*PDstandard4th1gt33) - 
+        PDstandard4th12gt11*SQR(gtu12) - PDstandard4th12gt22*SQR(gtu22) - PDstandard4th12gt33*SQR(gtu23);
+    
+    ddgtu2321  =  -(gtu12*gtu13*PDstandard4th12gt11) - gtu13*gtu22*PDstandard4th12gt21 - gtu12*gtu23*PDstandard4th12gt21 - 
+        gtu22*gtu23*PDstandard4th12gt22 - gtu13*gtu23*PDstandard4th12gt31 - gtu12*gtu33*PDstandard4th12gt31 - 
+        gtu22*gtu33*PDstandard4th12gt32 - gtu23*gtu33*PDstandard4th12gt33 - dgtu132*gtu12*PDstandard4th1gt11 - 
+        dgtu122*gtu13*PDstandard4th1gt11 - dgtu232*gtu12*PDstandard4th1gt21 - dgtu222*gtu13*PDstandard4th1gt21 - 
+        dgtu132*gtu22*PDstandard4th1gt21 - dgtu122*gtu23*PDstandard4th1gt21 - dgtu232*gtu22*PDstandard4th1gt22 - 
+        dgtu222*gtu23*PDstandard4th1gt22 - dgtu332*gtu12*PDstandard4th1gt31 - dgtu232*gtu13*PDstandard4th1gt31 - 
+        dgtu132*gtu23*PDstandard4th1gt31 - dgtu122*gtu33*PDstandard4th1gt31 - dgtu332*gtu22*PDstandard4th1gt32 - 
+        2*dgtu232*gtu23*PDstandard4th1gt32 - dgtu222*gtu33*PDstandard4th1gt32 - dgtu332*gtu23*PDstandard4th1gt33 - 
+        dgtu232*gtu33*PDstandard4th1gt33 - PDstandard4th12gt32*SQR(gtu23);
+    
+    ddgtu1131  =  -2*(gtu11*gtu12*PDstandard4th13gt21 + gtu11*gtu13*PDstandard4th13gt31 + gtu12*gtu13*PDstandard4th13gt32 + 
+           dgtu113*gtu11*PDstandard4th1gt11 + dgtu123*gtu11*PDstandard4th1gt21 + dgtu113*gtu12*PDstandard4th1gt21 + 
+           dgtu123*gtu12*PDstandard4th1gt22 + dgtu133*gtu11*PDstandard4th1gt31 + dgtu113*gtu13*PDstandard4th1gt31 + 
+           dgtu133*gtu12*PDstandard4th1gt32 + dgtu123*gtu13*PDstandard4th1gt32 + dgtu133*gtu13*PDstandard4th1gt33) - 
+        PDstandard4th13gt11*SQR(gtu11) - PDstandard4th13gt22*SQR(gtu12) - PDstandard4th13gt33*SQR(gtu13);
+    
+    ddgtu1231  =  -(gtu11*gtu12*PDstandard4th13gt11) - gtu11*gtu22*PDstandard4th13gt21 - gtu12*gtu22*PDstandard4th13gt22 - 
+        gtu12*gtu13*PDstandard4th13gt31 - gtu11*gtu23*PDstandard4th13gt31 - gtu13*gtu22*PDstandard4th13gt32 - 
+        gtu12*gtu23*PDstandard4th13gt32 - gtu13*gtu23*PDstandard4th13gt33 - dgtu123*gtu11*PDstandard4th1gt11 - 
+        dgtu113*gtu12*PDstandard4th1gt11 - dgtu223*gtu11*PDstandard4th1gt21 - 2*dgtu123*gtu12*PDstandard4th1gt21 - 
+        dgtu113*gtu22*PDstandard4th1gt21 - dgtu223*gtu12*PDstandard4th1gt22 - dgtu123*gtu22*PDstandard4th1gt22 - 
+        dgtu233*gtu11*PDstandard4th1gt31 - dgtu133*gtu12*PDstandard4th1gt31 - dgtu123*gtu13*PDstandard4th1gt31 - 
+        dgtu113*gtu23*PDstandard4th1gt31 - dgtu233*gtu12*PDstandard4th1gt32 - dgtu223*gtu13*PDstandard4th1gt32 - 
+        dgtu133*gtu22*PDstandard4th1gt32 - dgtu123*gtu23*PDstandard4th1gt32 - dgtu233*gtu13*PDstandard4th1gt33 - 
+        dgtu133*gtu23*PDstandard4th1gt33 - PDstandard4th13gt21*SQR(gtu12);
+    
+    ddgtu1331  =  -(gtu11*gtu13*PDstandard4th13gt11) - gtu12*gtu13*PDstandard4th13gt21 - gtu11*gtu23*PDstandard4th13gt21 - 
+        gtu12*gtu23*PDstandard4th13gt22 - gtu11*gtu33*PDstandard4th13gt31 - gtu13*gtu23*PDstandard4th13gt32 - 
+        gtu12*gtu33*PDstandard4th13gt32 - gtu13*gtu33*PDstandard4th13gt33 - dgtu133*gtu11*PDstandard4th1gt11 - 
+        dgtu113*gtu13*PDstandard4th1gt11 - dgtu233*gtu11*PDstandard4th1gt21 - dgtu133*gtu12*PDstandard4th1gt21 - 
+        dgtu123*gtu13*PDstandard4th1gt21 - dgtu113*gtu23*PDstandard4th1gt21 - dgtu233*gtu12*PDstandard4th1gt22 - 
+        dgtu123*gtu23*PDstandard4th1gt22 - dgtu333*gtu11*PDstandard4th1gt31 - 2*dgtu133*gtu13*PDstandard4th1gt31 - 
+        dgtu113*gtu33*PDstandard4th1gt31 - dgtu333*gtu12*PDstandard4th1gt32 - dgtu233*gtu13*PDstandard4th1gt32 - 
+        dgtu133*gtu23*PDstandard4th1gt32 - dgtu123*gtu33*PDstandard4th1gt32 - dgtu333*gtu13*PDstandard4th1gt33 - 
+        dgtu133*gtu33*PDstandard4th1gt33 - PDstandard4th13gt31*SQR(gtu13);
+    
+    ddgtu2331  =  -(gtu12*gtu13*PDstandard4th13gt11) - gtu13*gtu22*PDstandard4th13gt21 - gtu12*gtu23*PDstandard4th13gt21 - 
+        gtu22*gtu23*PDstandard4th13gt22 - gtu13*gtu23*PDstandard4th13gt31 - gtu12*gtu33*PDstandard4th13gt31 - 
+        gtu22*gtu33*PDstandard4th13gt32 - gtu23*gtu33*PDstandard4th13gt33 - dgtu133*gtu12*PDstandard4th1gt11 - 
+        dgtu123*gtu13*PDstandard4th1gt11 - dgtu233*gtu12*PDstandard4th1gt21 - dgtu223*gtu13*PDstandard4th1gt21 - 
+        dgtu133*gtu22*PDstandard4th1gt21 - dgtu123*gtu23*PDstandard4th1gt21 - dgtu233*gtu22*PDstandard4th1gt22 - 
+        dgtu223*gtu23*PDstandard4th1gt22 - dgtu333*gtu12*PDstandard4th1gt31 - dgtu233*gtu13*PDstandard4th1gt31 - 
+        dgtu133*gtu23*PDstandard4th1gt31 - dgtu123*gtu33*PDstandard4th1gt31 - dgtu333*gtu22*PDstandard4th1gt32 - 
+        2*dgtu233*gtu23*PDstandard4th1gt32 - dgtu223*gtu33*PDstandard4th1gt32 - dgtu333*gtu23*PDstandard4th1gt33 - 
+        dgtu233*gtu33*PDstandard4th1gt33 - PDstandard4th13gt32*SQR(gtu23);
+    
+    ddgtu3331  =  -2*(gtu13*gtu23*PDstandard4th13gt21 + gtu13*gtu33*PDstandard4th13gt31 + gtu23*gtu33*PDstandard4th13gt32 + 
+           dgtu133*gtu13*PDstandard4th1gt11 + dgtu233*gtu13*PDstandard4th1gt21 + dgtu133*gtu23*PDstandard4th1gt21 + 
+           dgtu233*gtu23*PDstandard4th1gt22 + dgtu333*gtu13*PDstandard4th1gt31 + dgtu133*gtu33*PDstandard4th1gt31 + 
+           dgtu333*gtu23*PDstandard4th1gt32 + dgtu233*gtu33*PDstandard4th1gt32 + dgtu333*gtu33*PDstandard4th1gt33) - 
+        PDstandard4th13gt11*SQR(gtu13) - PDstandard4th13gt22*SQR(gtu23) - PDstandard4th13gt33*SQR(gtu33);
+    
+    ddgtu1222  =  -(gtu11*gtu12*PDstandard4th22gt11) - gtu11*gtu22*PDstandard4th22gt21 - gtu12*gtu22*PDstandard4th22gt22 - 
+        gtu12*gtu13*PDstandard4th22gt31 - gtu11*gtu23*PDstandard4th22gt31 - gtu13*gtu22*PDstandard4th22gt32 - 
+        gtu12*gtu23*PDstandard4th22gt32 - gtu13*gtu23*PDstandard4th22gt33 - dgtu122*gtu11*PDstandard4th2gt11 - 
+        dgtu112*gtu12*PDstandard4th2gt11 - dgtu222*gtu11*PDstandard4th2gt21 - 2*dgtu122*gtu12*PDstandard4th2gt21 - 
+        dgtu112*gtu22*PDstandard4th2gt21 - dgtu222*gtu12*PDstandard4th2gt22 - dgtu122*gtu22*PDstandard4th2gt22 - 
+        dgtu232*gtu11*PDstandard4th2gt31 - dgtu132*gtu12*PDstandard4th2gt31 - dgtu122*gtu13*PDstandard4th2gt31 - 
+        dgtu112*gtu23*PDstandard4th2gt31 - dgtu232*gtu12*PDstandard4th2gt32 - dgtu222*gtu13*PDstandard4th2gt32 - 
+        dgtu132*gtu22*PDstandard4th2gt32 - dgtu122*gtu23*PDstandard4th2gt32 - dgtu232*gtu13*PDstandard4th2gt33 - 
+        dgtu132*gtu23*PDstandard4th2gt33 - PDstandard4th22gt21*SQR(gtu12);
+    
+    ddgtu2222  =  -2*(gtu12*gtu22*PDstandard4th22gt21 + gtu12*gtu23*PDstandard4th22gt31 + gtu22*gtu23*PDstandard4th22gt32 + 
+           dgtu122*gtu12*PDstandard4th2gt11 + dgtu222*gtu12*PDstandard4th2gt21 + dgtu122*gtu22*PDstandard4th2gt21 + 
+           dgtu222*gtu22*PDstandard4th2gt22 + dgtu232*gtu12*PDstandard4th2gt31 + dgtu122*gtu23*PDstandard4th2gt31 + 
+           dgtu232*gtu22*PDstandard4th2gt32 + dgtu222*gtu23*PDstandard4th2gt32 + dgtu232*gtu23*PDstandard4th2gt33) - 
+        PDstandard4th22gt11*SQR(gtu12) - PDstandard4th22gt22*SQR(gtu22) - PDstandard4th22gt33*SQR(gtu23);
+    
+    ddgtu2322  =  -(gtu12*gtu13*PDstandard4th22gt11) - gtu13*gtu22*PDstandard4th22gt21 - gtu12*gtu23*PDstandard4th22gt21 - 
+        gtu22*gtu23*PDstandard4th22gt22 - gtu13*gtu23*PDstandard4th22gt31 - gtu12*gtu33*PDstandard4th22gt31 - 
+        gtu22*gtu33*PDstandard4th22gt32 - gtu23*gtu33*PDstandard4th22gt33 - dgtu132*gtu12*PDstandard4th2gt11 - 
+        dgtu122*gtu13*PDstandard4th2gt11 - dgtu232*gtu12*PDstandard4th2gt21 - dgtu222*gtu13*PDstandard4th2gt21 - 
+        dgtu132*gtu22*PDstandard4th2gt21 - dgtu122*gtu23*PDstandard4th2gt21 - dgtu232*gtu22*PDstandard4th2gt22 - 
+        dgtu222*gtu23*PDstandard4th2gt22 - dgtu332*gtu12*PDstandard4th2gt31 - dgtu232*gtu13*PDstandard4th2gt31 - 
+        dgtu132*gtu23*PDstandard4th2gt31 - dgtu122*gtu33*PDstandard4th2gt31 - dgtu332*gtu22*PDstandard4th2gt32 - 
+        2*dgtu232*gtu23*PDstandard4th2gt32 - dgtu222*gtu33*PDstandard4th2gt32 - dgtu332*gtu23*PDstandard4th2gt33 - 
+        dgtu232*gtu33*PDstandard4th2gt33 - PDstandard4th22gt32*SQR(gtu23);
+    
+    ddgtu1232  =  -(gtu11*gtu12*PDstandard4th23gt11) - gtu11*gtu22*PDstandard4th23gt21 - gtu12*gtu22*PDstandard4th23gt22 - 
+        gtu12*gtu13*PDstandard4th23gt31 - gtu11*gtu23*PDstandard4th23gt31 - gtu13*gtu22*PDstandard4th23gt32 - 
+        gtu12*gtu23*PDstandard4th23gt32 - gtu13*gtu23*PDstandard4th23gt33 - dgtu123*gtu11*PDstandard4th2gt11 - 
+        dgtu113*gtu12*PDstandard4th2gt11 - dgtu223*gtu11*PDstandard4th2gt21 - 2*dgtu123*gtu12*PDstandard4th2gt21 - 
+        dgtu113*gtu22*PDstandard4th2gt21 - dgtu223*gtu12*PDstandard4th2gt22 - dgtu123*gtu22*PDstandard4th2gt22 - 
+        dgtu233*gtu11*PDstandard4th2gt31 - dgtu133*gtu12*PDstandard4th2gt31 - dgtu123*gtu13*PDstandard4th2gt31 - 
+        dgtu113*gtu23*PDstandard4th2gt31 - dgtu233*gtu12*PDstandard4th2gt32 - dgtu223*gtu13*PDstandard4th2gt32 - 
+        dgtu133*gtu22*PDstandard4th2gt32 - dgtu123*gtu23*PDstandard4th2gt32 - dgtu233*gtu13*PDstandard4th2gt33 - 
+        dgtu133*gtu23*PDstandard4th2gt33 - PDstandard4th23gt21*SQR(gtu12);
+    
+    ddgtu1332  =  -(gtu11*gtu13*PDstandard4th23gt11) - gtu12*gtu13*PDstandard4th23gt21 - gtu11*gtu23*PDstandard4th23gt21 - 
+        gtu12*gtu23*PDstandard4th23gt22 - gtu11*gtu33*PDstandard4th23gt31 - gtu13*gtu23*PDstandard4th23gt32 - 
+        gtu12*gtu33*PDstandard4th23gt32 - gtu13*gtu33*PDstandard4th23gt33 - dgtu133*gtu11*PDstandard4th2gt11 - 
+        dgtu113*gtu13*PDstandard4th2gt11 - dgtu233*gtu11*PDstandard4th2gt21 - dgtu133*gtu12*PDstandard4th2gt21 - 
+        dgtu123*gtu13*PDstandard4th2gt21 - dgtu113*gtu23*PDstandard4th2gt21 - dgtu233*gtu12*PDstandard4th2gt22 - 
+        dgtu123*gtu23*PDstandard4th2gt22 - dgtu333*gtu11*PDstandard4th2gt31 - 2*dgtu133*gtu13*PDstandard4th2gt31 - 
+        dgtu113*gtu33*PDstandard4th2gt31 - dgtu333*gtu12*PDstandard4th2gt32 - dgtu233*gtu13*PDstandard4th2gt32 - 
+        dgtu133*gtu23*PDstandard4th2gt32 - dgtu123*gtu33*PDstandard4th2gt32 - dgtu333*gtu13*PDstandard4th2gt33 - 
+        dgtu133*gtu33*PDstandard4th2gt33 - PDstandard4th23gt31*SQR(gtu13);
+    
+    ddgtu2232  =  -2*(gtu12*gtu22*PDstandard4th23gt21 + gtu12*gtu23*PDstandard4th23gt31 + gtu22*gtu23*PDstandard4th23gt32 + 
+           dgtu123*gtu12*PDstandard4th2gt11 + dgtu223*gtu12*PDstandard4th2gt21 + dgtu123*gtu22*PDstandard4th2gt21 + 
+           dgtu223*gtu22*PDstandard4th2gt22 + dgtu233*gtu12*PDstandard4th2gt31 + dgtu123*gtu23*PDstandard4th2gt31 + 
+           dgtu233*gtu22*PDstandard4th2gt32 + dgtu223*gtu23*PDstandard4th2gt32 + dgtu233*gtu23*PDstandard4th2gt33) - 
+        PDstandard4th23gt11*SQR(gtu12) - PDstandard4th23gt22*SQR(gtu22) - PDstandard4th23gt33*SQR(gtu23);
+    
+    ddgtu2332  =  -(gtu12*gtu13*PDstandard4th23gt11) - gtu13*gtu22*PDstandard4th23gt21 - gtu12*gtu23*PDstandard4th23gt21 - 
+        gtu22*gtu23*PDstandard4th23gt22 - gtu13*gtu23*PDstandard4th23gt31 - gtu12*gtu33*PDstandard4th23gt31 - 
+        gtu22*gtu33*PDstandard4th23gt32 - gtu23*gtu33*PDstandard4th23gt33 - dgtu133*gtu12*PDstandard4th2gt11 - 
+        dgtu123*gtu13*PDstandard4th2gt11 - dgtu233*gtu12*PDstandard4th2gt21 - dgtu223*gtu13*PDstandard4th2gt21 - 
+        dgtu133*gtu22*PDstandard4th2gt21 - dgtu123*gtu23*PDstandard4th2gt21 - dgtu233*gtu22*PDstandard4th2gt22 - 
+        dgtu223*gtu23*PDstandard4th2gt22 - dgtu333*gtu12*PDstandard4th2gt31 - dgtu233*gtu13*PDstandard4th2gt31 - 
+        dgtu133*gtu23*PDstandard4th2gt31 - dgtu123*gtu33*PDstandard4th2gt31 - dgtu333*gtu22*PDstandard4th2gt32 - 
+        2*dgtu233*gtu23*PDstandard4th2gt32 - dgtu223*gtu33*PDstandard4th2gt32 - dgtu333*gtu23*PDstandard4th2gt33 - 
+        dgtu233*gtu33*PDstandard4th2gt33 - PDstandard4th23gt32*SQR(gtu23);
+    
+    ddgtu3332  =  -2*(gtu13*gtu23*PDstandard4th23gt21 + gtu13*gtu33*PDstandard4th23gt31 + gtu23*gtu33*PDstandard4th23gt32 + 
+           dgtu133*gtu13*PDstandard4th2gt11 + dgtu233*gtu13*PDstandard4th2gt21 + dgtu133*gtu23*PDstandard4th2gt21 + 
+           dgtu233*gtu23*PDstandard4th2gt22 + dgtu333*gtu13*PDstandard4th2gt31 + dgtu133*gtu33*PDstandard4th2gt31 + 
+           dgtu333*gtu23*PDstandard4th2gt32 + dgtu233*gtu33*PDstandard4th2gt32 + dgtu333*gtu33*PDstandard4th2gt33) - 
+        PDstandard4th23gt11*SQR(gtu13) - PDstandard4th23gt22*SQR(gtu23) - PDstandard4th23gt33*SQR(gtu33);
+    
+    ddgtu1333  =  -(gtu11*gtu13*PDstandard4th33gt11) - gtu12*gtu13*PDstandard4th33gt21 - gtu11*gtu23*PDstandard4th33gt21 - 
+        gtu12*gtu23*PDstandard4th33gt22 - gtu11*gtu33*PDstandard4th33gt31 - gtu13*gtu23*PDstandard4th33gt32 - 
+        gtu12*gtu33*PDstandard4th33gt32 - gtu13*gtu33*PDstandard4th33gt33 - dgtu133*gtu11*PDstandard4th3gt11 - 
+        dgtu113*gtu13*PDstandard4th3gt11 - dgtu233*gtu11*PDstandard4th3gt21 - dgtu133*gtu12*PDstandard4th3gt21 - 
+        dgtu123*gtu13*PDstandard4th3gt21 - dgtu113*gtu23*PDstandard4th3gt21 - dgtu233*gtu12*PDstandard4th3gt22 - 
+        dgtu123*gtu23*PDstandard4th3gt22 - dgtu333*gtu11*PDstandard4th3gt31 - 2*dgtu133*gtu13*PDstandard4th3gt31 - 
+        dgtu113*gtu33*PDstandard4th3gt31 - dgtu333*gtu12*PDstandard4th3gt32 - dgtu233*gtu13*PDstandard4th3gt32 - 
+        dgtu133*gtu23*PDstandard4th3gt32 - dgtu123*gtu33*PDstandard4th3gt32 - dgtu333*gtu13*PDstandard4th3gt33 - 
+        dgtu133*gtu33*PDstandard4th3gt33 - PDstandard4th33gt31*SQR(gtu13);
+    
+    ddgtu2333  =  -(gtu12*gtu13*PDstandard4th33gt11) - gtu13*gtu22*PDstandard4th33gt21 - gtu12*gtu23*PDstandard4th33gt21 - 
+        gtu22*gtu23*PDstandard4th33gt22 - gtu13*gtu23*PDstandard4th33gt31 - gtu12*gtu33*PDstandard4th33gt31 - 
+        gtu22*gtu33*PDstandard4th33gt32 - gtu23*gtu33*PDstandard4th33gt33 - dgtu133*gtu12*PDstandard4th3gt11 - 
+        dgtu123*gtu13*PDstandard4th3gt11 - dgtu233*gtu12*PDstandard4th3gt21 - dgtu223*gtu13*PDstandard4th3gt21 - 
+        dgtu133*gtu22*PDstandard4th3gt21 - dgtu123*gtu23*PDstandard4th3gt21 - dgtu233*gtu22*PDstandard4th3gt22 - 
+        dgtu223*gtu23*PDstandard4th3gt22 - dgtu333*gtu12*PDstandard4th3gt31 - dgtu233*gtu13*PDstandard4th3gt31 - 
+        dgtu133*gtu23*PDstandard4th3gt31 - dgtu123*gtu33*PDstandard4th3gt31 - dgtu333*gtu22*PDstandard4th3gt32 - 
+        2*dgtu233*gtu23*PDstandard4th3gt32 - dgtu223*gtu33*PDstandard4th3gt32 - dgtu333*gtu23*PDstandard4th3gt33 - 
+        dgtu233*gtu33*PDstandard4th3gt33 - PDstandard4th33gt32*SQR(gtu23);
+    
+    ddgtu3333  =  -2*(gtu13*gtu23*PDstandard4th33gt21 + gtu13*gtu33*PDstandard4th33gt31 + gtu23*gtu33*PDstandard4th33gt32 + 
+           dgtu133*gtu13*PDstandard4th3gt11 + dgtu233*gtu13*PDstandard4th3gt21 + dgtu133*gtu23*PDstandard4th3gt21 + 
+           dgtu233*gtu23*PDstandard4th3gt22 + dgtu333*gtu13*PDstandard4th3gt31 + dgtu133*gtu33*PDstandard4th3gt31 + 
+           dgtu333*gtu23*PDstandard4th3gt32 + dgtu233*gtu33*PDstandard4th3gt32 + dgtu333*gtu33*PDstandard4th3gt33) - 
+        PDstandard4th33gt11*SQR(gtu13) - PDstandard4th33gt22*SQR(gtu23) - PDstandard4th33gt33*SQR(gtu33);
+    
+    Gt111  =  khalf*(gtu11*PDstandard4th1gt11 + 2*(gtu12*PDstandard4th1gt21 + gtu13*PDstandard4th1gt31) - 
+          gtu12*PDstandard4th2gt11 - gtu13*PDstandard4th3gt11);
+    
+    Gt211  =  khalf*(gtu12*PDstandard4th1gt11 + 2*(gtu22*PDstandard4th1gt21 + gtu23*PDstandard4th1gt31) - 
+          gtu22*PDstandard4th2gt11 - gtu23*PDstandard4th3gt11);
+    
+    Gt311  =  khalf*(gtu13*PDstandard4th1gt11 + 2*(gtu23*PDstandard4th1gt21 + gtu33*PDstandard4th1gt31) - 
+          gtu23*PDstandard4th2gt11 - gtu33*PDstandard4th3gt11);
+    
+    Gt121  =  khalf*(gtu12*PDstandard4th1gt22 + gtu11*PDstandard4th2gt11 + 
+          gtu13*(PDstandard4th1gt32 + PDstandard4th2gt31 - PDstandard4th3gt21));
+    
+    Gt221  =  khalf*(gtu22*PDstandard4th1gt22 + gtu12*PDstandard4th2gt11 + 
+          gtu23*(PDstandard4th1gt32 + PDstandard4th2gt31 - PDstandard4th3gt21));
+    
+    Gt321  =  khalf*(gtu23*PDstandard4th1gt22 + gtu13*PDstandard4th2gt11 + 
+          gtu33*(PDstandard4th1gt32 + PDstandard4th2gt31 - PDstandard4th3gt21));
+    
+    Gt131  =  khalf*(gtu13*PDstandard4th1gt33 + gtu11*PDstandard4th3gt11 + 
+          gtu12*(PDstandard4th1gt32 - PDstandard4th2gt31 + PDstandard4th3gt21));
+    
+    Gt231  =  khalf*(gtu23*PDstandard4th1gt33 + gtu12*PDstandard4th3gt11 + 
+          gtu22*(PDstandard4th1gt32 - PDstandard4th2gt31 + PDstandard4th3gt21));
+    
+    Gt331  =  khalf*(gtu33*PDstandard4th1gt33 + gtu13*PDstandard4th3gt11 + 
+          gtu23*(PDstandard4th1gt32 - PDstandard4th2gt31 + PDstandard4th3gt21));
+    
+    Gt122  =  khalf*(gtu11*(-PDstandard4th1gt22 + 2*PDstandard4th2gt21) + gtu12*PDstandard4th2gt22 + 
+          gtu13*(2*PDstandard4th2gt32 - PDstandard4th3gt22));
+    
+    Gt222  =  khalf*(gtu12*(-PDstandard4th1gt22 + 2*PDstandard4th2gt21) + gtu22*PDstandard4th2gt22 + 
+          gtu23*(2*PDstandard4th2gt32 - PDstandard4th3gt22));
+    
+    Gt322  =  khalf*(gtu13*(-PDstandard4th1gt22 + 2*PDstandard4th2gt21) + gtu23*PDstandard4th2gt22 + 
+          gtu33*(2*PDstandard4th2gt32 - PDstandard4th3gt22));
+    
+    Gt132  =  khalf*(gtu13*PDstandard4th2gt33 + gtu11*(-PDstandard4th1gt32 + PDstandard4th2gt31 + PDstandard4th3gt21) + 
+          gtu12*PDstandard4th3gt22);
+    
+    Gt232  =  khalf*(gtu23*PDstandard4th2gt33 + gtu12*(-PDstandard4th1gt32 + PDstandard4th2gt31 + PDstandard4th3gt21) + 
+          gtu22*PDstandard4th3gt22);
+    
+    Gt332  =  khalf*(gtu33*PDstandard4th2gt33 + gtu13*(-PDstandard4th1gt32 + PDstandard4th2gt31 + PDstandard4th3gt21) + 
+          gtu23*PDstandard4th3gt22);
+    
+    Gt133  =  khalf*(-(gtu11*PDstandard4th1gt33) - gtu12*PDstandard4th2gt33 + 2*gtu11*PDstandard4th3gt31 + 
+          2*gtu12*PDstandard4th3gt32 + gtu13*PDstandard4th3gt33);
+    
+    Gt233  =  khalf*(-(gtu12*PDstandard4th1gt33) - gtu22*PDstandard4th2gt33 + 2*gtu12*PDstandard4th3gt31 + 
+          2*gtu22*PDstandard4th3gt32 + gtu23*PDstandard4th3gt33);
+    
+    Gt333  =  khalf*(-(gtu13*PDstandard4th1gt33) - gtu23*PDstandard4th2gt33 + 2*gtu13*PDstandard4th3gt31 + 
+          2*gtu23*PDstandard4th3gt32 + gtu33*PDstandard4th3gt33);
+    
+    Rt11  =  -(gtu11*khalf*PDstandard4th11gt11) + gtu12*
+         (2*Gt211*Gt221*gt22L + 4*gt21L*Gt232*Gt311 + 6*Gt121*Gt311*gt31L + 4*gt11L*Gt131*Gt321 + 4*Gt221*gt31L*Gt321 + 
+           4*Gt211*gt31L*Gt322 + 2*Gt221*Gt311*gt32L + 2*Gt211*Gt321*gt32L + 4*gt31L*Gt321*Gt331 + 4*Gt311*gt31L*Gt332 + 
+           2*Gt311*Gt321*gt33L - PDstandard4th12gt11) + 
+        gtu13*(2*Gt231*Gt311*gt32L + 4*gt11L*Gt131*Gt331 + 2*Gt211*gt32L*Gt331 + 4*Gt211*gt31L*Gt332 + 
+           4*Gt311*gt31L*Gt333 + 2*Gt311*Gt331*gt33L - PDstandard4th13gt11) + 2*gt11L*PDstandard4th1Xt1 + 
+        gt21L*(6*Gt111*Gt221*gtu12 + 4*Gt211*Gt222*gtu12 + 6*Gt131*Gt211*gtu13 + 6*Gt121*Gt221*gtu22 + 
+           6*Gt131*Gt221*gtu23 + 6*Gt131*Gt231*gtu33 + 2*PDstandard4th1Xt2) + 2*gt31L*PDstandard4th1Xt3 - 
+        gtu22*khalf*PDstandard4th22gt11 - gtu23*PDstandard4th23gt11 - gtu33*khalf*PDstandard4th33gt11 + 
+        Gt111*(10*gt11L*Gt131*gtu13 + 6*gt21L*Gt231*gtu13 + 2*gt11L*Xt1L) + 
+        Gt211*(4*gt11L*Gt121*gtu11 + 6*Gt111*gt21L*gtu11 + 4*gt31L*Gt321*gtu11 + 2*Gt311*gt32L*gtu11 + 
+           4*gt11L*Gt122*gtu12 + 4*gt11L*Gt132*gtu13 + 2*gt22L*Gt231*gtu13 + 4*gt21L*Gt232*gtu13 + 2*gt21L*Xt1L) + 
+        Gt311*(4*gt21L*Gt231*gtu11 + 6*Gt111*gt31L*gtu11 + 4*gt11L*Gt132*gtu12 + 4*gt11L*Gt133*gtu13 + 
+           4*gt21L*Gt233*gtu13 + 6*Gt131*gt31L*gtu13 + 2*gt31L*Xt1L) + 
+        Gt121*(10*Gt111*gt11L*gtu12 + 6*Gt211*gt21L*gtu12 + 4*gt11L*Gt231*gtu13 + 6*gt31L*Gt321*gtu22 + 
+           10*gt11L*Gt131*gtu23 + 2*gt11L*Xt2L) + Gt221*
+         (4*gt31L*Gt322*gtu22 + 2*Gt321*gt32L*gtu22 + 2*gt22L*Gt231*gtu23 + 2*gt32L*Gt331*gtu23 + 4*gt31L*Gt332*gtu23 + 
+           2*gt21L*Xt2L) + Gt321*(4*gt21L*Gt231*gtu12 + 6*Gt111*gt31L*gtu12 + 4*Gt231*gt31L*gtu13 + 4*gt11L*Gt132*gtu22 + 
+           4*gt31L*Gt332*gtu22 + 4*gt11L*Gt133*gtu23 + 4*gt21L*Gt233*gtu23 + 6*Gt131*gt31L*gtu23 + 2*gt31L*Xt2L) + 
+        2*gt11L*Gt131*Xt3L + Gt231*(4*gt11L*Gt122*gtu23 + 6*Gt121*gt21L*gtu23 + 4*gt31L*Gt322*gtu23 + 2*Gt321*gt32L*gtu23 + 
+           4*gt11L*Gt132*gtu33 + 2*gt32L*Gt331*gtu33 + 4*gt31L*Gt332*gtu33 + 2*gt21L*Xt3L) + 
+        Gt331*(4*gt21L*Gt231*gtu13 + 6*Gt111*gt31L*gtu13 + 4*gt11L*Gt132*gtu23 + 4*gt21L*Gt232*gtu23 + 
+           6*Gt121*gt31L*gtu23 + 2*Gt321*gt33L*gtu23 + 4*gt11L*Gt133*gtu33 + 4*gt21L*Gt233*gtu33 + 6*Gt131*gt31L*gtu33 + 
+           4*gt31L*Gt333*gtu33 + 2*gt31L*Xt3L) + 5*gt11L*gtu11*SQR(Gt111) + 5*gt11L*gtu22*SQR(Gt121) + 
+        5*gt11L*gtu33*SQR(Gt131) + gt22L*gtu11*SQR(Gt211) + gt22L*gtu22*SQR(Gt221) + 
+        4*(Gt211*gt21L*Gt221*gtu11 + gt11L*Gt131*Gt311*gtu11 + Gt311*gt31L*Gt331*gtu11 + gt11L*Gt121*Gt221*gtu12 + 
+           gt21L*Gt221*Gt231*gtu13 + gt11L*Gt122*Gt221*gtu22 + gt21L*Gt221*Gt222*gtu22 + gt21L*Gt232*Gt321*gtu22 + 
+           gt11L*Gt132*Gt221*gtu23 + gt21L*Gt222*Gt231*gtu23 + gt21L*Gt221*Gt232*gtu23 + gt31L*Gt331*Gt332*gtu23 + 
+           gt31L*Gt321*Gt333*gtu23 + gt21L*Gt231*Gt232*gtu33 + gt21L*gtu12*SQR(Gt221)) + gt22L*gtu33*SQR(Gt231) + 
+        gt33L*gtu11*SQR(Gt311) + gt33L*gtu22*SQR(Gt321) + 4*gt31L*gtu13*SQR(Gt331) + gt33L*gtu33*SQR(Gt331);
+    
+    Rt21  =  gt22L*PDstandard4th1Xt2 + gt32L*PDstandard4th1Xt3 + gt11L*PDstandard4th2Xt1 + 
+        gt21L*(PDstandard4th1Xt1 + PDstandard4th2Xt2) + gt31L*PDstandard4th2Xt3 + 
+        khalf*(-(gtu11*PDstandard4th11gt21) - 2*gtu12*PDstandard4th12gt21 - 2*gtu13*PDstandard4th13gt21 - 
+           gtu22*PDstandard4th22gt21 - 2*gtu23*PDstandard4th23gt21 - gtu33*PDstandard4th33gt21) + 
+        (gt11L*Gt121 + gt21L*(Gt111 + Gt221) + Gt211*gt22L + gt31L*Gt321 + Gt311*gt32L)*Xt1L + 
+        (gt11L*Gt122 + gt21L*(Gt121 + Gt222) + Gt221*gt22L + gt31L*Gt322 + Gt321*gt32L)*Xt2L + 
+        (gt11L*Gt132 + gt22L*Gt231 + gt21L*(Gt131 + Gt232) + gt32L*Gt331 + gt31L*Gt332)*Xt3L + 
+        gtu11*(gt11L*(Gt121*(3*Gt111 + 2*Gt221) + 2*Gt131*Gt321) + 
+           Gt111*(gt21L*Gt221 + gt31L*Gt321 + 2*(Gt211*gt22L + Gt311*gt32L)) + 
+           Gt211*(5*Gt121*gt21L + 3*(Gt221*gt22L + Gt321*gt32L)) + gt31L*(3*Gt121*Gt311 + 2*Gt321*(Gt221 + Gt331)) + 
+           Gt311*(Gt221*gt32L + Gt321*gt33L) + 2*(Gt311*(Gt131*gt21L + gt22L*Gt231 + gt32L*Gt331) + 
+              gt21L*(Gt231*Gt321 + SQR(Gt111) + SQR(Gt221)))) + 
+        gtu22*(gt11L*(Gt122*(3*Gt121 + 2*Gt222) + 2*Gt132*Gt322) + 
+           Gt121*(gt21L*Gt222 + gt31L*Gt322 + 2*(Gt221*gt22L + Gt321*gt32L)) + 
+           Gt221*(5*Gt122*gt21L + 3*(Gt222*gt22L + Gt322*gt32L)) + gt31L*(3*Gt122*Gt321 + 2*Gt322*(Gt222 + Gt332)) + 
+           Gt321*(Gt222*gt32L + Gt322*gt33L) + 2*(Gt321*(Gt132*gt21L + gt22L*Gt232 + gt32L*Gt332) + 
+              gt21L*(Gt232*Gt322 + SQR(Gt121) + SQR(Gt222)))) + 
+        gtu33*(gt11L*(Gt132*(3*Gt131 + 2*Gt232) + 2*Gt133*Gt332) + 
+           Gt131*(gt21L*Gt232 + 2*(gt22L*Gt231 + gt32L*Gt331) + gt31L*Gt332) + 
+           Gt231*(5*Gt132*gt21L + 3*(gt22L*Gt232 + gt32L*Gt332)) + 
+           Gt331*(3*Gt132*gt31L + gt32L*(Gt232 + 2*Gt333) + Gt332*gt33L) + 
+           2*((Gt133*gt21L + gt22L*Gt233)*Gt331 + Gt332*(gt21L*Gt233 + gt31L*(Gt232 + Gt333)) + 
+              gt21L*(SQR(Gt131) + SQR(Gt232)))) + gtu12*
+         (Gt122*(Gt111*gt11L + 3*Gt211*gt21L + Gt311*gt31L) + 
+           gt21L*(Gt111*Gt222 + Gt221*(4*Gt121 + 2*Gt222) + 2*(Gt132*Gt311 + Gt232*Gt321)) + 
+           gt31L*((Gt111 + 2*Gt221)*Gt322 + Gt321*(4*Gt121 + 2*Gt332)) + 
+           gt32L*(2*Gt221*Gt321 + 3*Gt211*Gt322 + Gt311*(Gt222 + 2*Gt332)) + 
+           gt11L*(2*(Gt122*Gt221 + Gt132*Gt321) + 3*SQR(Gt121)) + gt22L*(3*Gt211*Gt222 + 2*Gt232*Gt311 + SQR(Gt221)) + 
+           2*(gt11L*(Gt111*Gt122 + Gt121*Gt222 + Gt131*Gt322) + 
+              gt21L*(Gt122*Gt211 + Gt121*(Gt111 + Gt221) + Gt221*Gt222 + Gt131*Gt321 + Gt231*Gt322) + 
+              Gt111*(Gt121*gt21L + Gt221*gt22L + Gt321*gt32L) + gt31L*(Gt122*Gt311 + Gt222*Gt321 + Gt322*Gt331) + 
+              gt32L*(Gt121*Gt311 + Gt321*(Gt221 + Gt331)) + gt22L*(Gt121*Gt211 + Gt231*Gt321 + SQR(Gt221))) + 
+           gt33L*(Gt311*Gt322 + SQR(Gt321))) + gtu13*
+         (gt22L*(3*Gt211*Gt232 + 2*Gt233*Gt311) + Gt132*(Gt111*gt11L + 3*Gt211*gt21L + Gt311*gt31L) + 
+           gt11L*(3*Gt121*Gt131 + 2*(Gt132*Gt221 + Gt133*Gt321)) + 
+           gt21L*(Gt131*Gt221 + 3*Gt121*Gt231 + Gt111*Gt232 + 2*(Gt133*Gt311 + Gt233*Gt321)) + 
+           Gt221*(gt22L*Gt231 + 2*gt21L*Gt232 + gt32L*Gt331) + gt31L*(3*Gt121*Gt331 + Gt111*Gt332) + 
+           gt32L*(3*Gt211*Gt332 + Gt311*(Gt232 + 2*Gt333)) + Gt311*Gt332*gt33L + 
+           Gt321*(Gt231*gt32L + gt31L*(Gt131 + 2*Gt333) + Gt331*gt33L) + 
+           2*(Gt111*(Gt131*gt21L + gt22L*Gt231 + gt32L*Gt331) + gt22L*(Gt131*Gt211 + Gt231*(Gt221 + Gt331)) + 
+              gt11L*(Gt111*Gt132 + Gt121*Gt232 + Gt131*Gt332) + gt31L*(Gt132*Gt311 + Gt232*Gt321 + (Gt221 + Gt331)*Gt332) + 
+              gt21L*(Gt132*Gt211 + Gt221*Gt232 + Gt131*(Gt111 + Gt331) + Gt231*(Gt121 + Gt332)) + 
+              gt32L*(Gt131*Gt311 + Gt231*Gt321 + SQR(Gt331)))) + 
+        gtu23*(gt22L*(3*Gt221*Gt232 + 2*Gt233*Gt321) + Gt132*(gt11L*Gt121 + 3*gt21L*Gt221 + gt31L*Gt321) + 
+           gt11L*(3*Gt122*Gt131 + 2*(Gt132*Gt222 + Gt133*Gt322)) + 
+           gt21L*(Gt131*Gt222 + 3*Gt122*Gt231 + Gt121*Gt232 + 2*(Gt133*Gt321 + Gt233*Gt322)) + 
+           Gt222*(gt22L*Gt231 + 2*gt21L*Gt232 + gt32L*Gt331) + gt31L*(3*Gt122*Gt331 + Gt121*Gt332) + 
+           gt32L*(3*Gt221*Gt332 + Gt321*(Gt232 + 2*Gt333)) + Gt321*Gt332*gt33L + 
+           Gt322*(Gt231*gt32L + gt31L*(Gt131 + 2*Gt333) + Gt331*gt33L) + 
+           2*(Gt131*(Gt121*gt21L + Gt221*gt22L + Gt321*gt32L) + Gt231*(Gt122*gt21L + Gt222*gt22L + Gt322*gt32L) + 
+              Gt121*(Gt131*gt21L + gt22L*Gt231 + gt32L*Gt331) + Gt331*(Gt132*gt21L + gt22L*Gt232 + gt32L*Gt332) + 
+              gt11L*(Gt122*Gt232 + Gt132*(Gt121 + Gt332)) + gt21L*(Gt132*Gt221 + Gt232*(Gt222 + Gt332)) + 
+              gt31L*(Gt132*Gt321 + Gt232*Gt322 + Gt222*Gt332 + SQR(Gt332))));
+    
+    Rt31  =  gt32L*PDstandard4th1Xt2 + gt33L*PDstandard4th1Xt3 + 
+        khalf*(-(gtu11*PDstandard4th11gt31) - 2*gtu12*PDstandard4th12gt31 - 2*gtu13*PDstandard4th13gt31 - 
+           gtu22*PDstandard4th22gt31 - 2*gtu23*PDstandard4th23gt31 - gtu33*PDstandard4th33gt31) + gt11L*PDstandard4th3Xt1 + 
+        gt21L*PDstandard4th3Xt2 + gt31L*(PDstandard4th1Xt1 + PDstandard4th3Xt3) + 
+        (gt11L*Gt131 + gt21L*Gt231 + Gt211*gt32L + gt31L*(Gt111 + Gt331) + Gt311*gt33L)*Xt1L + 
+        (gt11L*Gt132 + gt21L*Gt232 + Gt221*gt32L + gt31L*(Gt121 + Gt332) + Gt321*gt33L)*Xt2L + 
+        (gt11L*Gt133 + gt21L*Gt233 + Gt231*gt32L + gt31L*(Gt131 + Gt333) + Gt331*gt33L)*Xt3L + 
+        gtu12*(gt22L*(Gt221*Gt231 + Gt211*Gt232) + Gt132*(Gt111*gt11L + Gt211*gt21L + 3*Gt311*gt31L) + 
+           gt21L*((Gt121 + 2*Gt222)*Gt231 + Gt232*(Gt111 + 2*Gt331)) + 
+           gt11L*(3*Gt121*Gt131 + 2*(Gt122*Gt231 + Gt132*Gt331)) + gt31L*(Gt121*Gt331 + Gt111*Gt332) + 
+           gt32L*(Gt231*Gt321 + Gt221*Gt331 + Gt211*(2*Gt222 + Gt332)) + (2*Gt211*Gt322 + Gt321*Gt331)*gt33L + 
+           3*(Gt131*(gt21L*Gt221 + gt31L*Gt321) + Gt311*(Gt232*gt32L + Gt332*gt33L)) + 
+           2*(gt11L*(Gt111*Gt132 + Gt121*Gt232 + Gt131*Gt332) + gt21L*(Gt132*Gt211 + Gt221*Gt232 + Gt231*Gt332) + 
+              gt31L*(Gt122*Gt211 + Gt121*(2*Gt111 + Gt221) + Gt132*Gt311 + (Gt131 + Gt232)*Gt321 + Gt231*Gt322 + 
+                 2*Gt331*Gt332) + (Gt121*Gt311 + Gt321*(Gt221 + Gt331))*gt33L + Gt111*(Gt221*gt32L + Gt321*gt33L) + 
+              gt32L*(Gt121*Gt211 + Gt231*Gt321 + SQR(Gt221)))) + 
+        gtu23*(Gt233*(Gt221*gt22L + 2*gt31L*Gt322 + Gt321*gt32L) + Gt132*(gt11L*Gt131 + gt21L*Gt231 + 3*gt31L*Gt331) + 
+           Gt232*(Gt131*gt21L + gt22L*Gt231 + 3*gt32L*Gt331) + (Gt131*gt31L + Gt231*gt32L)*Gt332 + 
+           gt21L*((Gt121 + 2*Gt222)*Gt233 + 2*Gt232*Gt333) + gt11L*(3*Gt121*Gt133 + 2*(Gt122*Gt233 + Gt132*Gt333)) + 
+           Gt333*(Gt121*gt31L + Gt221*gt32L + Gt321*gt33L) + 3*(Gt133*(gt21L*Gt221 + gt31L*Gt321) + Gt331*Gt332*gt33L) + 
+           2*((Gt222*Gt231 + Gt221*(Gt131 + Gt232) + Gt233*Gt321)*gt32L + gt11L*(Gt132*(Gt131 + Gt232) + Gt133*Gt332) + 
+              gt31L*(Gt121*Gt131 + Gt122*Gt231 + Gt133*Gt321 + Gt132*(Gt221 + Gt331) + Gt332*(Gt232 + 2*Gt333)) + 
+              (Gt231*Gt322 + Gt221*Gt332 + Gt321*(Gt131 + Gt333))*gt33L + Gt121*(Gt131*gt31L + Gt231*gt32L + Gt331*gt33L) + 
+              gt21L*(Gt132*Gt231 + Gt233*Gt332 + SQR(Gt232)))) + 
+        gtu11*(Gt231*(Gt211*gt22L + 2*(gt21L*Gt221 + gt31L*Gt321) + 3*Gt311*gt32L) + 
+           gt21L*(3*Gt131*Gt211 + Gt231*(Gt111 + 2*Gt331)) + gt11L*(2*Gt121*Gt231 + Gt131*(3*Gt111 + 2*Gt331)) + 
+           3*Gt311*Gt331*gt33L + Gt211*(gt32L*Gt331 + 2*Gt321*gt33L) + 
+           gt31L*(5*Gt131*Gt311 + Gt111*Gt331 + 2*(Gt121*Gt211 + SQR(Gt111))) + 
+           2*(Gt211*(Gt111 + Gt221)*gt32L + Gt111*Gt311*gt33L + gt31L*SQR(Gt331))) + 
+        gtu13*(Gt133*(Gt111*gt11L + Gt211*gt21L + 3*Gt311*gt31L) + gt32L*(3*Gt233*Gt311 + 2*Gt231*(Gt111 + Gt331)) + 
+           gt21L*(Gt111*Gt233 + 2*(Gt231*Gt232 + Gt233*Gt331)) + Gt111*(gt31L*Gt333 + 2*Gt331*gt33L) + 
+           Gt211*(gt22L*Gt233 + gt32L*Gt333 + 2*(Gt132*gt31L + Gt232*gt32L + Gt332*gt33L)) + 
+           gt11L*(2*(Gt132*Gt231 + Gt133*Gt331) + 3*SQR(Gt131)) + gt22L*SQR(Gt231) + gt33L*(3*Gt311*Gt333 + SQR(Gt331)) + 
+           2*(gt32L*(Gt131*Gt211 + Gt231*(Gt221 + Gt331)) + Gt131*(Gt111*gt31L + 2*(gt21L*Gt231 + gt31L*Gt331)) + 
+              gt11L*(Gt111*Gt133 + Gt121*Gt233 + Gt131*Gt333) + gt21L*(Gt133*Gt211 + Gt221*Gt233 + Gt231*Gt333) + 
+              gt31L*(Gt133*Gt311 + Gt233*Gt321 + Gt131*(Gt111 + Gt331) + Gt231*(Gt121 + Gt332) + 2*Gt331*Gt333) + 
+              gt33L*(Gt131*Gt311 + Gt231*Gt321 + SQR(Gt331)))) + 
+        gtu22*(Gt232*(Gt221*gt22L + 2*(gt21L*Gt222 + gt31L*Gt322) + 3*Gt321*gt32L) + 
+           gt21L*(3*Gt132*Gt221 + Gt232*(Gt121 + 2*Gt332)) + gt11L*(2*Gt122*Gt232 + Gt132*(3*Gt121 + 2*Gt332)) + 
+           3*Gt321*Gt332*gt33L + Gt221*(gt32L*Gt332 + 2*Gt322*gt33L) + 
+           gt31L*(5*Gt132*Gt321 + Gt121*Gt332 + 2*(Gt122*Gt221 + SQR(Gt121))) + 
+           2*(Gt221*(Gt121 + Gt222)*gt32L + Gt121*Gt321*gt33L + gt31L*SQR(Gt332))) + 
+        gtu33*(Gt233*(gt22L*Gt231 + 2*gt21L*Gt232 + 3*gt32L*Gt331) + gt21L*(3*Gt133*Gt231 + Gt233*(Gt131 + 2*Gt333)) + 
+           gt11L*(2*Gt132*Gt233 + Gt133*(3*Gt131 + 2*Gt333)) + 3*Gt331*Gt333*gt33L + Gt231*(gt32L*Gt333 + 2*Gt332*gt33L) + 
+           gt31L*(5*Gt133*Gt331 + Gt131*Gt333 + 2*SQR(Gt131)) + 
+           2*(Gt231*(Gt132*gt31L + (Gt131 + Gt232)*gt32L) + Gt131*Gt331*gt33L + gt31L*(Gt233*Gt332 + SQR(Gt333))));
+    
+    Rt22  =  6*(Gt122*gt21L*Gt221*gtu12 + Gt121*gt21L*Gt222*gtu12 + Gt222*Gt321*gt32L*gtu12 + Gt221*Gt322*gt32L*gtu12 + 
+           Gt132*gt21L*Gt221*gtu13 + Gt122*gt21L*Gt222*gtu22 + Gt132*gt21L*Gt222*gtu23 + Gt232*gt32L*Gt332*gtu33) - 
+        gtu11*khalf*PDstandard4th11gt22 + gtu12*(2*Gt122*gt31L*Gt321 + 4*Gt131*gt21L*Gt322 + 4*Gt121*Gt321*gt32L + 
+           4*Gt322*gt32L*Gt331 + 4*Gt321*gt32L*Gt332 + 2*Gt321*Gt322*gt33L - PDstandard4th12gt22) - 
+        gtu13*PDstandard4th13gt22 - gtu22*khalf*PDstandard4th22gt22 + 
+        gtu23*(2*Gt132*gt31L*Gt322 + 4*Gt122*gt32L*Gt331 + 4*gt22L*Gt232*Gt332 + 4*Gt322*gt32L*Gt333 + 
+           2*Gt322*Gt332*gt33L - PDstandard4th23gt22) + 2*gt21L*PDstandard4th2Xt1 + 
+        gt22L*(10*Gt221*Gt222*gtu12 + 4*Gt232*Gt321*gtu12 + 4*Gt132*Gt211*gtu13 + 4*Gt122*Gt221*gtu22 + 
+           4*Gt132*Gt221*gtu23 + 10*Gt222*Gt232*gtu23 + 4*Gt233*Gt322*gtu23 + 4*Gt132*Gt231*gtu33 + 2*PDstandard4th2Xt2) + 
+        gt32L*(4*Gt121*Gt311*gtu11 + 6*Gt221*Gt321*gtu11 + 4*Gt122*Gt311*gtu12 + 4*Gt132*Gt311*gtu13 + 
+           6*Gt232*Gt321*gtu13 + 4*Gt121*Gt331*gtu13 + 4*Gt122*Gt321*gtu22 + 6*Gt232*Gt322*gtu23 + 4*Gt132*Gt331*gtu33 + 
+           2*PDstandard4th2Xt3) - gtu33*khalf*PDstandard4th33gt22 + 2*Gt221*gt22L*Xt1L + 
+        Gt121*(4*Gt111*gt21L*gtu11 + 6*gt21L*Gt221*gtu11 + 2*gt11L*Gt122*gtu12 + 2*gt11L*Gt132*gtu13 + 
+           4*Gt122*gt21L*gtu22 + 4*Gt132*gt21L*gtu23 + 2*gt21L*Xt1L) + 
+        Gt321*(4*gt22L*Gt231*gtu11 + 2*Gt121*gt31L*gtu11 + 4*gt32L*Gt331*gtu11 + 4*Gt132*gt21L*gtu12 + 
+           4*Gt133*gt21L*gtu13 + 4*gt22L*Gt233*gtu13 + 2*Gt132*gt31L*gtu13 + 2*Gt332*gt33L*gtu13 + 4*Gt132*gt32L*gtu23 + 
+           2*gt32L*Xt1L) + 2*Gt222*gt22L*Xt2L + Gt122*(2*gt11L*Gt132*gtu23 + 4*gt22L*Gt231*gtu23 + 2*gt21L*Xt2L) + 
+        Gt322*(4*gt22L*Gt231*gtu12 + 2*Gt121*gt31L*gtu12 + 4*Gt132*gt21L*gtu22 + 2*Gt122*gt31L*gtu22 + 
+           6*Gt222*gt32L*gtu22 + 4*Gt133*gt21L*gtu23 + 2*gt32L*Xt2L) + 2*Gt132*gt21L*Xt3L + 
+        Gt232*(6*Gt121*gt21L*gtu13 + 10*Gt221*gt22L*gtu13 + 4*gt22L*Gt322*gtu22 + 6*Gt122*gt21L*gtu23 + 
+           6*Gt132*gt21L*gtu33 + 2*gt22L*Xt3L) + Gt332*
+         (2*Gt121*gt31L*gtu13 + 6*Gt221*gt32L*gtu13 + 4*Gt322*gt32L*gtu22 + 4*Gt132*gt21L*gtu23 + 2*Gt122*gt31L*gtu23 + 
+           6*Gt222*gt32L*gtu23 + 4*Gt133*gt21L*gtu33 + 4*gt22L*Gt233*gtu33 + 2*Gt132*gt31L*gtu33 + 2*gt32L*Xt3L) + 
+        gt11L*gtu11*SQR(Gt121) + 4*(Gt121*Gt211*gt22L*gtu11 + Gt131*gt21L*Gt321*gtu11 + Gt111*Gt122*gt21L*gtu12 + 
+           Gt122*Gt211*gt22L*gtu12 + Gt121*Gt221*gt22L*gtu12 + Gt121*Gt131*gt21L*gtu13 + Gt111*Gt132*gt21L*gtu13 + 
+           Gt121*gt22L*Gt231*gtu13 + Gt131*gt21L*Gt332*gtu13 + gt22L*Gt231*Gt332*gtu13 + gt32L*Gt331*Gt332*gtu13 + 
+           Gt321*gt32L*Gt333*gtu13 + Gt122*Gt131*gt21L*gtu23 + Gt131*Gt132*gt21L*gtu33 + gt32L*Gt332*Gt333*gtu33 + 
+           gt21L*gtu12*SQR(Gt121)) + gt11L*gtu22*SQR(Gt122) + gt11L*gtu33*SQR(Gt132) + 5*gt22L*gtu11*SQR(Gt221) + 
+        5*gt22L*gtu22*SQR(Gt222) + 5*gt22L*gtu33*SQR(Gt232) + gt33L*gtu11*SQR(Gt321) + gt33L*gtu22*SQR(Gt322) + 
+        4*gt32L*gtu23*SQR(Gt332) + gt33L*gtu33*SQR(Gt332);
+    
+    Rt32  =  gt31L*PDstandard4th2Xt1 + gt33L*PDstandard4th2Xt3 + 
+        khalf*(-(gtu11*PDstandard4th11gt32) - 2*gtu12*PDstandard4th12gt32 - 2*gtu13*PDstandard4th13gt32 - 
+           gtu22*PDstandard4th22gt32 - 2*gtu23*PDstandard4th23gt32 - gtu33*PDstandard4th33gt32) + gt21L*PDstandard4th3Xt1 + 
+        gt22L*PDstandard4th3Xt2 + gt32L*(PDstandard4th2Xt2 + PDstandard4th3Xt3) + 
+        (Gt131*gt21L + gt22L*Gt231 + Gt121*gt31L + gt32L*(Gt221 + Gt331) + Gt321*gt33L)*Xt1L + 
+        (Gt132*gt21L + gt22L*Gt232 + Gt122*gt31L + gt32L*(Gt222 + Gt332) + Gt322*gt33L)*Xt2L + 
+        (Gt133*gt21L + gt22L*Gt233 + Gt132*gt31L + gt32L*(Gt232 + Gt333) + Gt332*gt33L)*Xt3L + 
+        gtu12*(gt11L*(Gt122*Gt131 + Gt121*Gt132) + gt32L*
+            (2*(Gt132*Gt311 + Gt131*Gt321) + 5*(Gt232*Gt321 + Gt231*Gt322) + Gt222*(4*Gt221 + Gt331) + 
+              (Gt221 + 4*Gt331)*Gt332) + gt21L*(3*Gt122*Gt231 + Gt132*(Gt221 + 2*Gt331) + Gt131*(Gt222 + 2*Gt332)) + 
+           3*(Gt121*gt21L*Gt232 + gt22L*(Gt222*Gt231 + Gt221*Gt232) + gt31L*(Gt132*Gt321 + Gt131*Gt322) + 
+              (Gt322*Gt331 + Gt321*Gt332)*gt33L) + 2*
+            ((Gt122*Gt221 + Gt121*Gt222)*gt31L + Gt111*(Gt132*gt21L + Gt122*gt31L) + 
+              gt22L*(Gt132*Gt211 + Gt131*Gt221 + Gt232*Gt331 + Gt231*Gt332) + (Gt222*Gt321 + Gt221*Gt322)*gt33L + 
+              Gt122*(Gt211*gt32L + Gt311*gt33L) + Gt121*(Gt131*gt21L + Gt221*gt32L + Gt321*gt33L)) + 
+           gt31L*(Gt122*Gt331 + Gt121*Gt332 + 2*SQR(Gt121))) + 
+        gtu13*(gt11L*(Gt131*Gt132 + Gt121*Gt133) + Gt133*(gt21L*Gt221 + 3*gt31L*Gt321 + 2*(Gt211*gt22L + Gt311*gt32L)) + 
+           gt32L*(5*Gt233*Gt321 + Gt232*(4*Gt221 + Gt331) + Gt231*(2*Gt121 + 5*Gt332) + Gt221*Gt333) + 
+           Gt331*(2*gt22L*Gt233 + Gt132*gt31L + 4*gt32L*Gt333) + 
+           Gt131*(2*(gt22L*Gt231 + Gt121*gt31L + gt32L*Gt331) + gt31L*Gt332 + gt21L*(Gt232 + 2*Gt333)) + 
+           Gt121*(gt31L*Gt333 + 2*Gt331*gt33L) + 3*(Gt231*(Gt132*gt21L + gt22L*Gt232) + (Gt121*gt21L + Gt221*gt22L)*Gt233 + 
+              (Gt331*Gt332 + Gt321*Gt333)*gt33L) + 2*
+            (Gt111*(Gt133*gt21L + Gt132*gt31L) + gt31L*(Gt132*Gt221 + Gt121*Gt232 + Gt131*Gt332) + gt22L*Gt231*Gt333 + 
+              (Gt232*Gt321 + Gt221*Gt332)*gt33L + Gt132*(Gt211*gt32L + Gt311*gt33L) + gt21L*(Gt133*Gt331 + SQR(Gt131)))) + 
+        gtu11*(Gt131*(gt11L*Gt121 + gt21L*Gt221 + 3*gt31L*Gt321 + 2*(Gt211*gt22L + Gt311*gt32L)) + 
+           (Gt121*gt31L + Gt221*gt32L)*Gt331 + Gt231*(5*Gt321*gt32L + 2*gt22L*Gt331) + 
+           3*((Gt121*gt21L + Gt221*gt22L)*Gt231 + Gt321*Gt331*gt33L) + 
+           2*(Gt111*(Gt131*gt21L + Gt121*gt31L) + Gt131*gt21L*Gt331 + Gt221*Gt321*gt33L + 
+              Gt121*(Gt221*gt31L + Gt211*gt32L + Gt311*gt33L) + gt32L*(SQR(Gt221) + SQR(Gt331)))) + 
+        gtu23*(Gt233*(Gt122*gt21L + Gt222*gt22L + 3*Gt322*gt32L) + 
+           Gt133*(gt11L*Gt122 + 3*gt31L*Gt322 + gt21L*(Gt222 + 2*Gt332)) + 
+           Gt132*(4*gt21L*Gt232 + 2*(gt22L*Gt231 + gt32L*Gt331 + gt31L*(Gt222 + Gt332))) + 
+           gt32L*(4*Gt232*Gt332 + Gt222*Gt333) + Gt122*(gt31L*Gt333 + 2*Gt331*gt33L) + gt11L*SQR(Gt132) + 
+           3*(Gt322*Gt333*gt33L + gt22L*SQR(Gt232)) + gt33L*SQR(Gt332) + 
+           2*(Gt131*(Gt132*gt21L + Gt122*gt31L) + Gt133*(Gt121*gt21L + Gt221*gt22L + Gt321*gt32L) + 
+              gt31L*(Gt122*Gt232 + Gt132*(Gt121 + Gt332)) + Gt233*(Gt122*gt21L + Gt322*gt32L + gt22L*(Gt222 + Gt332)) + 
+              (Gt132*gt21L + gt22L*Gt232)*Gt333 + gt32L*
+               (Gt132*Gt221 + Gt122*Gt231 + Gt232*(2*Gt222 + Gt332) + 2*Gt332*Gt333) + 
+              gt33L*(Gt132*Gt321 + Gt232*Gt322 + Gt222*Gt332 + SQR(Gt332)))) + 
+        gtu22*(Gt132*(gt11L*Gt122 + gt21L*Gt222 + 3*gt31L*Gt322 + 2*(Gt221*gt22L + Gt321*gt32L)) + 
+           (Gt122*gt31L + Gt222*gt32L)*Gt332 + Gt232*(5*Gt322*gt32L + 2*gt22L*Gt332) + 
+           3*((Gt122*gt21L + Gt222*gt22L)*Gt232 + Gt322*Gt332*gt33L) + 
+           2*(Gt121*(Gt132*gt21L + Gt122*gt31L) + Gt132*gt21L*Gt332 + Gt222*Gt322*gt33L + 
+              Gt122*(Gt222*gt31L + Gt221*gt32L + Gt321*gt33L) + gt32L*(SQR(Gt222) + SQR(Gt332)))) + 
+        gtu33*(Gt133*(gt11L*Gt132 + gt21L*Gt232 + 2*(gt22L*Gt231 + gt32L*Gt331)) + (Gt132*gt31L + Gt232*gt32L)*Gt333 + 
+           Gt233*(5*gt32L*Gt332 + 2*gt22L*Gt333) + 3*
+            ((Gt132*gt21L + gt22L*Gt232)*Gt233 + Gt332*(Gt133*gt31L + Gt333*gt33L)) + 
+           2*(Gt131*(Gt133*gt21L + Gt132*gt31L) + Gt133*gt21L*Gt333 + Gt232*Gt332*gt33L + 
+              Gt132*(Gt232*gt31L + Gt231*gt32L + Gt331*gt33L) + gt32L*(SQR(Gt232) + SQR(Gt333))));
+    
+    Rt33  =  6*(Gt133*gt31L*Gt331*gtu13 + Gt233*gt32L*Gt331*gtu13 + Gt131*gt31L*Gt333*gtu13 + Gt231*gt32L*Gt333*gtu13 + 
+           Gt132*gt31L*Gt332*gtu22 + Gt133*gt31L*Gt332*gtu23 + Gt132*gt31L*Gt333*gtu23 + Gt232*gt32L*Gt333*gtu23 + 
+           Gt133*gt31L*Gt333*gtu33) + gtu12*(2*gt22L*Gt231*Gt232 + 4*Gt111*Gt132*gt31L + 4*Gt132*Gt211*gt32L + 
+           4*Gt221*Gt232*gt32L + 6*Gt132*gt31L*Gt331 + 6*Gt232*gt32L*Gt331 + 6*Gt131*gt31L*Gt332 + 6*Gt231*gt32L*Gt332 + 
+           4*Gt132*Gt311*gt33L - PDstandard4th12gt33) - gtu13*PDstandard4th13gt33 - gtu22*khalf*PDstandard4th22gt33 - 
+        gtu23*PDstandard4th23gt33 - gtu33*khalf*PDstandard4th33gt33 + 
+        2*(Gt132*gt21L*Gt231*gtu12 + Gt131*gt21L*Gt232*gtu12 + Gt133*gt21L*Gt231*gtu13 + Gt131*gt21L*Gt233*gtu13 + 
+           gt22L*Gt231*Gt233*gtu13 + Gt132*gt21L*Gt232*gtu22 + gt11L*Gt132*Gt133*gtu23 + Gt132*gt21L*Gt233*gtu23 + 
+           gt22L*Gt232*Gt233*gtu23 + Gt133*gt21L*Gt233*gtu33 + gt31L*PDstandard4th3Xt1) + 2*gt32L*PDstandard4th3Xt2 + 
+        gt33L*(4*Gt231*Gt322*gtu12 + 10*Gt331*Gt332*gtu12 + 4*Gt133*Gt311*gtu13 + 4*Gt231*Gt332*gtu13 + 
+           10*Gt331*Gt333*gtu13 + 4*Gt132*Gt321*gtu22 + 4*Gt133*Gt321*gtu23 + 4*Gt133*Gt331*gtu33 + 2*PDstandard4th3Xt3) + 
+        2*Gt231*gt32L*Xt1L + 2*Gt331*gt33L*Xt1L + Gt131*
+         (2*gt21L*Gt231*gtu11 + 4*Gt111*gt31L*gtu11 + 2*gt11L*Gt132*gtu12 + 2*gt11L*Gt133*gtu13 + 4*Gt132*gt31L*gtu23 + 
+           4*Gt133*gt31L*gtu33 + 2*gt31L*Xt1L) + 2*Gt132*gt31L*Xt2L + 
+        Gt232*(4*Gt222*gt32L*gtu22 + 6*gt32L*Gt332*gtu22 + 2*Gt133*gt21L*gtu23 + 4*Gt233*gt32L*gtu33 + 2*gt32L*Xt2L) + 
+        Gt332*(4*Gt232*gt33L*gtu23 + 10*Gt333*gt33L*gtu23 + 4*Gt233*gt33L*gtu33 + 2*gt33L*Xt2L) + 2*Gt133*gt31L*Xt3L + 
+        2*Gt333*gt33L*Xt3L + Gt233*(4*Gt222*gt32L*gtu23 + 6*gt32L*Gt332*gtu23 + 4*Gt132*gt31L*gtu33 + 6*gt32L*Gt333*gtu33 + 
+           2*gt32L*Xt3L) + gtu11*(4*Gt221*Gt231*gt32L + 6*Gt131*gt31L*Gt331 + 6*Gt231*gt32L*Gt331 + 4*Gt131*Gt311*gt33L + 
+           4*Gt231*Gt321*gt33L - khalf*PDstandard4th11gt33 + gt11L*SQR(Gt131)) + 
+        4*(Gt121*Gt231*gt31L*gtu11 + Gt131*Gt211*gt32L*gtu11 + Gt121*Gt131*gt31L*gtu12 + Gt122*Gt231*gt31L*gtu12 + 
+           Gt121*Gt232*gt31L*gtu12 + Gt131*Gt221*gt32L*gtu12 + Gt222*Gt231*gt32L*gtu12 + Gt131*Gt321*gt33L*gtu12 + 
+           Gt232*Gt321*gt33L*gtu12 + Gt111*Gt133*gt31L*gtu13 + Gt132*Gt231*gt31L*gtu13 + Gt121*Gt233*gt31L*gtu13 + 
+           Gt133*Gt211*gt32L*gtu13 + Gt131*Gt231*gt32L*gtu13 + Gt231*Gt232*gt32L*gtu13 + Gt221*Gt233*gt32L*gtu13 + 
+           Gt233*Gt321*gt33L*gtu13 + Gt131*Gt331*gt33L*gtu13 + Gt121*Gt132*gt31L*gtu22 + Gt122*Gt232*gt31L*gtu22 + 
+           Gt132*Gt221*gt32L*gtu22 + Gt232*Gt322*gt33L*gtu22 + Gt121*Gt133*gt31L*gtu23 + Gt132*Gt232*gt31L*gtu23 + 
+           Gt122*Gt233*gt31L*gtu23 + Gt133*Gt221*gt32L*gtu23 + Gt132*Gt231*gt32L*gtu23 + Gt233*Gt322*gt33L*gtu23 + 
+           Gt132*Gt331*gt33L*gtu23 + Gt133*Gt231*gt32L*gtu33 + gt31L*gtu13*SQR(Gt131)) + gt11L*gtu22*SQR(Gt132) + 
+        gt11L*gtu33*SQR(Gt133) + gt22L*gtu11*SQR(Gt231) + gt22L*gtu22*SQR(Gt232) + 4*gt32L*gtu23*SQR(Gt232) + 
+        gt22L*gtu33*SQR(Gt233) + 5*gt33L*gtu11*SQR(Gt331) + 5*gt33L*gtu22*SQR(Gt332) + 5*gt33L*gtu33*SQR(Gt333);
+    
+    Rphi11  =  2*(-PDstandard4th11phi - gt11L*gtu11*PDstandard4th11phi - 2*gt11L*gtu12*PDstandard4th12phi - 
+          2*gt11L*gtu13*PDstandard4th13phi - gt11L*gtu22*PDstandard4th22phi - 2*gt11L*gtu23*PDstandard4th23phi - 
+          gt11L*gtu33*PDstandard4th33phi + Gt311*PDstandard4th3phi + gt11L*Gt311*gtu11*PDstandard4th3phi + 
+          2*gt11L*Gt321*gtu12*PDstandard4th3phi + 2*gt11L*Gt331*gtu13*PDstandard4th3phi + 
+          gt11L*Gt322*gtu22*PDstandard4th3phi + 2*gt11L*Gt332*gtu23*PDstandard4th3phi + 
+          gt11L*Gt333*gtu33*PDstandard4th3phi + PDstandard4th1phi*
+           (Gt111 + Gt111*gt11L*gtu11 + 2*gt11L*Gt121*gtu12 + 2*gt11L*Gt131*gtu13 + gt11L*Gt122*gtu22 + 
+             2*gt11L*Gt132*gtu23 + gt11L*Gt133*gtu33 - 4*gt11L*gtu12*PDstandard4th2phi - 4*gt11L*gtu13*PDstandard4th3phi) + 
+          PDstandard4th2phi*(Gt211 + gt11L*Gt211*gtu11 + 
+             gt11L*(2*Gt221*gtu12 + 2*Gt231*gtu13 + Gt222*gtu22 + 2*Gt232*gtu23 + Gt233*gtu33) - 
+             4*gt11L*gtu23*PDstandard4th3phi) + (2 - 2*gt11L*gtu11)*SQR(PDstandard4th1phi) - 
+          2*gt11L*gtu22*SQR(PDstandard4th2phi) - 2*gt11L*gtu33*SQR(PDstandard4th3phi));
+    
+    Rphi21  =  2*(-(gt21L*gtu11*PDstandard4th11phi) - PDstandard4th12phi - 2*gt21L*gtu12*PDstandard4th12phi - 
+          2*gt21L*gtu13*PDstandard4th13phi - gt21L*gtu22*PDstandard4th22phi - 2*gt21L*gtu23*PDstandard4th23phi - 
+          gt21L*gtu33*PDstandard4th33phi + Gt321*PDstandard4th3phi + gt21L*Gt311*gtu11*PDstandard4th3phi + 
+          2*gt21L*Gt321*gtu12*PDstandard4th3phi + 2*gt21L*Gt331*gtu13*PDstandard4th3phi + 
+          gt21L*Gt322*gtu22*PDstandard4th3phi + 2*gt21L*Gt332*gtu23*PDstandard4th3phi + 
+          gt21L*Gt333*gtu33*PDstandard4th3phi + PDstandard4th1phi*
+           (Gt121 + Gt111*gt21L*gtu11 + 2*Gt121*gt21L*gtu12 + 2*Gt131*gt21L*gtu13 + Gt122*gt21L*gtu22 + 
+             2*Gt132*gt21L*gtu23 + Gt133*gt21L*gtu33 + (2 - 4*gt21L*gtu12)*PDstandard4th2phi - 
+             4*gt21L*gtu13*PDstandard4th3phi) + PDstandard4th2phi*
+           (Gt221 + 2*gt21L*Gt221*gtu12 + gt21L*(Gt211*gtu11 + 2*Gt231*gtu13 + Gt222*gtu22 + 2*Gt232*gtu23 + Gt233*gtu33) - 
+             4*gt21L*gtu23*PDstandard4th3phi) - 2*gt21L*gtu11*SQR(PDstandard4th1phi) - 
+          2*gt21L*gtu22*SQR(PDstandard4th2phi) - 2*gt21L*gtu33*SQR(PDstandard4th3phi));
+    
+    Rphi31  =  2*(-PDstandard4th13phi + gt31L*(-(gtu11*PDstandard4th11phi) - 2*gtu12*PDstandard4th12phi - 
+             2*gtu13*PDstandard4th13phi) - gt31L*gtu22*PDstandard4th22phi - 2*gt31L*gtu23*PDstandard4th23phi - 
+          gt31L*gtu33*PDstandard4th33phi + Gt331*PDstandard4th3phi + Gt311*gt31L*gtu11*PDstandard4th3phi + 
+          2*gt31L*Gt321*gtu12*PDstandard4th3phi + 2*gt31L*Gt331*gtu13*PDstandard4th3phi + 
+          gt31L*Gt322*gtu22*PDstandard4th3phi + 2*gt31L*Gt332*gtu23*PDstandard4th3phi + 
+          gt31L*Gt333*gtu33*PDstandard4th3phi + PDstandard4th1phi*
+           (Gt131 + Gt111*gt31L*gtu11 + 2*Gt121*gt31L*gtu12 + 2*Gt131*gt31L*gtu13 + Gt122*gt31L*gtu22 + 
+             2*Gt132*gt31L*gtu23 + Gt133*gt31L*gtu33 - 4*gt31L*gtu12*PDstandard4th2phi + 
+             (2 - 4*gt31L*gtu13)*PDstandard4th3phi) + 
+          PDstandard4th2phi*(Gt231 + 2*Gt231*gt31L*gtu13 + 
+             gt31L*(Gt211*gtu11 + 2*Gt221*gtu12 + Gt222*gtu22 + 2*Gt232*gtu23 + Gt233*gtu33) - 
+             4*gt31L*gtu23*PDstandard4th3phi) - 2*gt31L*gtu11*SQR(PDstandard4th1phi) - 
+          2*gt31L*gtu22*SQR(PDstandard4th2phi) - 2*gt31L*gtu33*SQR(PDstandard4th3phi));
+    
+    Rphi22  =  2*(-PDstandard4th22phi + gt22L*(-(gtu11*PDstandard4th11phi) - 2*gtu12*PDstandard4th12phi - 
+             2*gtu13*PDstandard4th13phi - gtu22*PDstandard4th22phi) - 2*gt22L*gtu23*PDstandard4th23phi - 
+          gt22L*gtu33*PDstandard4th33phi + Gt322*PDstandard4th3phi + gt22L*Gt311*gtu11*PDstandard4th3phi + 
+          2*gt22L*Gt321*gtu12*PDstandard4th3phi + 2*gt22L*Gt331*gtu13*PDstandard4th3phi + 
+          gt22L*Gt322*gtu22*PDstandard4th3phi + 2*gt22L*Gt332*gtu23*PDstandard4th3phi + 
+          gt22L*Gt333*gtu33*PDstandard4th3phi + PDstandard4th1phi*
+           (Gt122 + Gt111*gt22L*gtu11 + 2*Gt121*gt22L*gtu12 + 2*Gt131*gt22L*gtu13 + Gt122*gt22L*gtu22 + 
+             2*Gt132*gt22L*gtu23 + Gt133*gt22L*gtu33 - 4*gt22L*gtu12*PDstandard4th2phi - 4*gt22L*gtu13*PDstandard4th3phi) + 
+          PDstandard4th2phi*(Gt222 + Gt222*gt22L*gtu22 + 
+             gt22L*(Gt211*gtu11 + 2*Gt221*gtu12 + 2*Gt231*gtu13 + 2*Gt232*gtu23 + Gt233*gtu33) - 
+             4*gt22L*gtu23*PDstandard4th3phi) - 2*gt22L*gtu11*SQR(PDstandard4th1phi) + 
+          (2 - 2*gt22L*gtu22)*SQR(PDstandard4th2phi) - 2*gt22L*gtu33*SQR(PDstandard4th3phi));
+    
+    Rphi32  =  2*(-PDstandard4th23phi + gt32L*(-(gtu11*PDstandard4th11phi) - 2*gtu12*PDstandard4th12phi - 
+             2*gtu13*PDstandard4th13phi - gtu22*PDstandard4th22phi - 2*gtu23*PDstandard4th23phi) - 
+          gt32L*gtu33*PDstandard4th33phi + Gt332*PDstandard4th3phi + Gt311*gt32L*gtu11*PDstandard4th3phi + 
+          2*Gt321*gt32L*gtu12*PDstandard4th3phi + 2*gt32L*Gt331*gtu13*PDstandard4th3phi + 
+          Gt322*gt32L*gtu22*PDstandard4th3phi + 2*gt32L*Gt332*gtu23*PDstandard4th3phi + 
+          gt32L*Gt333*gtu33*PDstandard4th3phi + PDstandard4th1phi*
+           (Gt132 + Gt111*gt32L*gtu11 + 2*Gt121*gt32L*gtu12 + 2*Gt131*gt32L*gtu13 + Gt122*gt32L*gtu22 + 
+             2*Gt132*gt32L*gtu23 + Gt133*gt32L*gtu33 - 4*gt32L*gtu12*PDstandard4th2phi - 4*gt32L*gtu13*PDstandard4th3phi) + 
+          PDstandard4th2phi*(Gt232 + 2*Gt232*gt32L*gtu23 + 
+             gt32L*(Gt211*gtu11 + 2*Gt221*gtu12 + 2*Gt231*gtu13 + Gt222*gtu22 + Gt233*gtu33) + 
+             (2 - 4*gt32L*gtu23)*PDstandard4th3phi) - 2*gt32L*gtu11*SQR(PDstandard4th1phi) - 
+          2*gt32L*gtu22*SQR(PDstandard4th2phi) - 2*gt32L*gtu33*SQR(PDstandard4th3phi));
+    
+    Rphi33  =  2*(-PDstandard4th33phi + (Gt333 + gt33L*
+              (Gt322*gtu22 + 2*(Gt321*gtu12 + Gt331*gtu13 + Gt332*gtu23) + Gt333*gtu33))*PDstandard4th3phi + 
+          PDstandard4th2phi*(Gt233 + gt33L*(Gt211*gtu11 + Gt222*gtu22 + 2*(Gt221*gtu12 + Gt231*gtu13 + Gt232*gtu23) + 
+                Gt233*gtu33 - 4*gtu23*PDstandard4th3phi)) + 
+          PDstandard4th1phi*(Gt133 + gt33L*(Gt111*gtu11 + Gt122*gtu22 + 2*(Gt121*gtu12 + Gt131*gtu13 + Gt132*gtu23) + 
+                Gt133*gtu33 - 4*(gtu12*PDstandard4th2phi + gtu13*PDstandard4th3phi))) + 2*SQR(PDstandard4th3phi) + 
+          gt33L*(-(gtu11*PDstandard4th11phi) - 2*gtu12*PDstandard4th12phi - 2*gtu13*PDstandard4th13phi - 
+             gtu22*PDstandard4th22phi - 2*gtu23*PDstandard4th23phi - gtu33*PDstandard4th33phi + 
+             Gt311*gtu11*PDstandard4th3phi - 2*gtu11*SQR(PDstandard4th1phi) - 2*gtu22*SQR(PDstandard4th2phi) - 
+             2*gtu33*SQR(PDstandard4th3phi)));
+    
+    R11  =  Rphi11 + Rt11;
+    
+    R21  =  Rphi21 + Rt21;
+    
+    R31  =  Rphi31 + Rt31;
+    
+    R22  =  Rphi22 + Rt22;
+    
+    R32  =  Rphi32 + Rt32;
+    
+    R33  =  Rphi33 + Rt33;
+    
+    Atm11  =  At11L*gtu11 + At21L*gtu12 + At31L*gtu13;
+    
+    Atm21  =  At11L*gtu12 + At21L*gtu22 + At31L*gtu23;
+    
+    Atm31  =  At11L*gtu13 + At21L*gtu23 + At31L*gtu33;
+    
+    Atm12  =  At21L*gtu11 + At22L*gtu12 + At32L*gtu13;
+    
+    Atm22  =  At21L*gtu12 + At22L*gtu22 + At32L*gtu23;
+    
+    Atm32  =  At21L*gtu13 + At22L*gtu23 + At32L*gtu33;
+    
+    Atm13  =  At31L*gtu11 + At32L*gtu12 + At33L*gtu13;
+    
+    Atm23  =  At31L*gtu12 + At32L*gtu22 + At33L*gtu23;
+    
+    Atm33  =  At31L*gtu13 + At32L*gtu23 + At33L*gtu33;
+    
+    Atu11  =  Atm11*gtu11 + Atm12*gtu12 + Atm13*gtu13;
+    
+    Atu12  =  Atm11*gtu12 + Atm12*gtu22 + Atm13*gtu23;
+    
+    Atu13  =  Atm11*gtu13 + Atm12*gtu23 + Atm13*gtu33;
+    
+    Atu22  =  Atm21*gtu12 + Atm22*gtu22 + Atm23*gtu23;
+    
+    Atu23  =  Atm21*gtu13 + Atm22*gtu23 + Atm23*gtu33;
+    
+    Atu33  =  Atm31*gtu13 + Atm32*gtu23 + Atm33*gtu33;
+    
+    e4phi  =  exp(4*phiL);
+    
+    em4phi  =  INV(e4phi);
+    
+    g11  =  e4phi*gt11L;
+    
+    g21  =  e4phi*gt21L;
+    
+    g31  =  e4phi*gt31L;
+    
+    g22  =  e4phi*gt22L;
+    
+    g32  =  e4phi*gt32L;
+    
+    g33  =  e4phi*gt33L;
+    
+    detg  =  2*g21*g31*g32 + g33*(g11*g22 - SQR(g21)) - g22*SQR(g31) - g11*SQR(g32);
+    
+    gu11  =  em4phi*gtu11;
+    
+    gu12  =  em4phi*gtu12;
+    
+    gu13  =  em4phi*gtu13;
+    
+    gu22  =  em4phi*gtu22;
+    
+    gu23  =  em4phi*gtu23;
+    
+    gu33  =  em4phi*gtu33;
+    
+    ddetg1  =  e4phi*(ddetgt1 + 4*detgt*PDstandard4th1phi);
+    
+    ddetg2  =  e4phi*(ddetgt2 + 4*detgt*PDstandard4th2phi);
+    
+    ddetg3  =  e4phi*(ddetgt3 + 4*detgt*PDstandard4th3phi);
+    
+    G111  =  -((-6*detg*Gt111 + ddetg1*(-6 + g11*gu11) + g11*(ddetg2*gu12 + ddetg3*gu13))*INV(detg))/6.;
+    
+    G211  =  ((6*detg*Gt211 - g11*(ddetg1*gu12 + ddetg2*gu22 + ddetg3*gu23))*INV(detg))/6.;
+    
+    G311  =  ((6*detg*Gt311 - g11*(ddetg1*gu13 + ddetg2*gu23 + ddetg3*gu33))*INV(detg))/6.;
+    
+    G121  =  -((-6*detg*Gt121 + ddetg2*(-3 + g21*gu12) + g21*(ddetg1*gu11 + ddetg3*gu13))*INV(detg))/6.;
+    
+    G221  =  -((-6*detg*Gt221 + ddetg1*(-3 + g21*gu12) + g21*(ddetg2*gu22 + ddetg3*gu23))*INV(detg))/6.;
+    
+    G321  =  ((6*detg*Gt321 - g21*(ddetg1*gu13 + ddetg2*gu23 + ddetg3*gu33))*INV(detg))/6.;
+    
+    G131  =  -((-6*detg*Gt131 + g31*(ddetg1*gu11 + ddetg2*gu12) + ddetg3*(-3 + g31*gu13))*INV(detg))/6.;
+    
+    G231  =  ((6*detg*Gt231 - g31*(ddetg1*gu12 + ddetg2*gu22 + ddetg3*gu23))*INV(detg))/6.;
+    
+    G331  =  -((-6*detg*Gt331 + ddetg1*(-3 + g31*gu13) + g31*(ddetg2*gu23 + ddetg3*gu33))*INV(detg))/6.;
+    
+    G122  =  ((6*detg*Gt122 - g22*(ddetg1*gu11 + ddetg2*gu12 + ddetg3*gu13))*INV(detg))/6.;
+    
+    G222  =  -((-6*detg*Gt222 + ddetg2*(-6 + g22*gu22) + g22*(ddetg1*gu12 + ddetg3*gu23))*INV(detg))/6.;
+    
+    G322  =  ((6*detg*Gt322 - g22*(ddetg1*gu13 + ddetg2*gu23 + ddetg3*gu33))*INV(detg))/6.;
+    
+    G132  =  ((6*detg*Gt132 - g32*(ddetg1*gu11 + ddetg2*gu12 + ddetg3*gu13))*INV(detg))/6.;
+    
+    G232  =  -((-6*detg*Gt232 + g32*(ddetg1*gu12 + ddetg2*gu22) + ddetg3*(-3 + g32*gu23))*INV(detg))/6.;
+    
+    G332  =  -((-6*detg*Gt332 + ddetg2*(-3 + g32*gu23) + g32*(ddetg1*gu13 + ddetg3*gu33))*INV(detg))/6.;
+    
+    G133  =  ((6*detg*Gt133 - g33*(ddetg1*gu11 + ddetg2*gu12 + ddetg3*gu13))*INV(detg))/6.;
+    
+    G233  =  ((6*detg*Gt233 - g33*(ddetg1*gu12 + ddetg2*gu22 + ddetg3*gu23))*INV(detg))/6.;
+    
+    G333  =  -((-6*detg*Gt333 + g33*(ddetg1*gu13 + ddetg2*gu23) + ddetg3*(-6 + g33*gu33))*INV(detg))/6.;
+    
+    phirhsL  =  beta1L*PDstandard4th1phi + beta2L*PDstandard4th2phi + beta3L*PDstandard4th3phi + 
+        ((PDstandard4th1beta1 + PDstandard4th2beta2 + PDstandard4th3beta3)*phiL)/6. - (alphaL*trKL)/6.;
+    
+    gt11rhsL  =  -2*alphaL*At11L + 2*(gt11L*PDstandard4th1beta1 + gt21L*PDstandard4th1beta2 + gt31L*PDstandard4th1beta3) + 
+        beta1L*PDstandard4th1gt11 + beta2L*PDstandard4th2gt11 - 
+        gt11L*ktwothird*(PDstandard4th1beta1 + PDstandard4th2beta2 + PDstandard4th3beta3) + beta3L*PDstandard4th3gt11;
+    
+    gt21rhsL  =  -2*alphaL*At21L + gt22L*PDstandard4th1beta2 + gt32L*PDstandard4th1beta3 + beta1L*PDstandard4th1gt21 + 
+        gt11L*PDstandard4th2beta1 + gt31L*PDstandard4th2beta3 + beta2L*PDstandard4th2gt21 + 
+        gt21L*(kthird*(PDstandard4th1beta1 + PDstandard4th2beta2) - ktwothird*PDstandard4th3beta3) + 
+        beta3L*PDstandard4th3gt21;
+    
+    gt31rhsL  =  -2*alphaL*At31L + gt32L*PDstandard4th1beta2 + gt33L*PDstandard4th1beta3 + beta1L*PDstandard4th1gt31 + 
+        beta2L*PDstandard4th2gt31 + gt11L*PDstandard4th3beta1 + gt21L*PDstandard4th3beta2 + 
+        gt31L*(-(ktwothird*PDstandard4th2beta2) + kthird*(PDstandard4th1beta1 + PDstandard4th3beta3)) + 
+        beta3L*PDstandard4th3gt31;
+    
+    gt22rhsL  =  -2*alphaL*At22L + beta1L*PDstandard4th1gt22 + 
+        2*(gt21L*PDstandard4th2beta1 + gt22L*PDstandard4th2beta2 + gt32L*PDstandard4th2beta3) + beta2L*PDstandard4th2gt22 - 
+        gt22L*ktwothird*(PDstandard4th1beta1 + PDstandard4th2beta2 + PDstandard4th3beta3) + beta3L*PDstandard4th3gt22;
+    
+    gt32rhsL  =  -2*alphaL*At32L + beta1L*PDstandard4th1gt32 + gt31L*PDstandard4th2beta1 + gt33L*PDstandard4th2beta3 + 
+        beta2L*PDstandard4th2gt32 + gt21L*PDstandard4th3beta1 + gt22L*PDstandard4th3beta2 + 
+        gt32L*(-(ktwothird*PDstandard4th1beta1) + kthird*(PDstandard4th2beta2 + PDstandard4th3beta3)) + 
+        beta3L*PDstandard4th3gt32;
+    
+    gt33rhsL  =  -2*alphaL*At33L + beta1L*PDstandard4th1gt33 + beta2L*PDstandard4th2gt33 - 
+        gt33L*ktwothird*(PDstandard4th1beta1 + PDstandard4th2beta2 + PDstandard4th3beta3) + 
+        2*(gt31L*PDstandard4th3beta1 + gt32L*PDstandard4th3beta2 + gt33L*PDstandard4th3beta3) + beta3L*PDstandard4th3gt33;
+    
+    Xt1rhsL  =  kthird*(-3*(beta1L*(ddgtu1111 + ddgtu1221 + ddgtu1331) + beta2L*(ddgtu1121 + ddgtu1222 + ddgtu1332) + 
+             beta3L*(ddgtu1131 + ddgtu1232 + ddgtu1333)) + 16*(gtu12*PDstandard4th12beta1 + gtu13*PDstandard4th13beta1) + 
+          (7*dgtu111 + 4*(dgtu122 + dgtu133))*PDstandard4th1beta1 + 
+          gtu11*(10*PDstandard4th11beta1 + 4*(PDstandard4th12beta2 + PDstandard4th13beta3) - 4*alphaL*PDstandard4th1trK) + 
+          12*gtu23*PDstandard4th23beta1 + (9*dgtu121 + 6*dgtu233)*PDstandard4th2beta1 + 
+          (dgtu122 - 2*(dgtu111 + dgtu133))*PDstandard4th2beta2 + 
+          4*(gtu12*(PDstandard4th22beta2 + PDstandard4th23beta3) + gtu13*(PDstandard4th23beta2 + PDstandard4th33beta3)) - 
+          6*(Atu11*PDstandard4th1alpha + Atu12*PDstandard4th2alpha + Atu13*PDstandard4th3alpha) + 
+          (9*dgtu131 + 6*dgtu333)*PDstandard4th3beta1 + 
+          6*(gtu22*PDstandard4th22beta1 + dgtu222*PDstandard4th2beta1 + gtu33*PDstandard4th33beta1 + 
+             dgtu232*PDstandard4th3beta1) + 3*(dgtu112*PDstandard4th1beta2 + dgtu113*PDstandard4th1beta3 + 
+             dgtu123*PDstandard4th2beta3 + dgtu132*PDstandard4th3beta2) + 
+          (-2*(dgtu111 + dgtu122) + dgtu133)*PDstandard4th3beta3 + 
+          alphaL*(12*(Atu12*Gt121 + Atu13*Gt131 + Atu23*Gt132) + 6*(Atu11*Gt111 + Atu22*Gt122 + Atu33*Gt133) + 
+             36*(Atu11*PDstandard4th1phi + Atu12*PDstandard4th2phi + Atu13*PDstandard4th3phi) - 
+             4*(gtu12*PDstandard4th2trK + gtu13*PDstandard4th3trK)));
+    
+    Xt2rhsL  =  kthird*(-3*(beta1L*(ddgtu1211 + ddgtu2221 + ddgtu2331) + beta2L*(ddgtu1221 + ddgtu2222 + ddgtu2332) + 
+             beta3L*(ddgtu1231 + ddgtu2232 + ddgtu2333)) + 12*gtu13*PDstandard4th13beta2 + 
+          (dgtu121 - 2*(dgtu222 + dgtu233))*PDstandard4th1beta1 + (9*dgtu122 + 6*dgtu133)*PDstandard4th1beta2 + 
+          gtu12*(16*PDstandard4th12beta2 + 4*PDstandard4th13beta3 - 4*alphaL*PDstandard4th1trK) + 
+          (7*dgtu222 + 4*dgtu233)*PDstandard4th2beta2 + 
+          4*(gtu12*PDstandard4th11beta1 + gtu23*PDstandard4th13beta1 + 
+             gtu22*(PDstandard4th12beta1 + PDstandard4th23beta3) + dgtu121*PDstandard4th2beta2) + 
+          gtu22*(10*PDstandard4th22beta2 - 4*alphaL*PDstandard4th2trK) - 
+          6*(Atu12*PDstandard4th1alpha + Atu22*PDstandard4th2alpha + Atu23*PDstandard4th3alpha) + 
+          3*(dgtu123*PDstandard4th1beta3 + dgtu221*PDstandard4th2beta1 + dgtu223*PDstandard4th2beta3 + 
+             dgtu231*PDstandard4th3beta1) + (9*dgtu232 + 6*dgtu333)*PDstandard4th3beta2 + 
+          6*(gtu11*PDstandard4th11beta2 + dgtu111*PDstandard4th1beta2 + gtu33*PDstandard4th33beta2 + 
+             dgtu131*PDstandard4th3beta2) + (-2*(dgtu121 + dgtu222) + dgtu233)*PDstandard4th3beta3 + 
+          alphaL*(12*(Atu12*Gt221 + Atu13*Gt231 + Atu23*Gt232) + 6*(Atu11*Gt211 + Atu22*Gt222 + Atu33*Gt233) + 
+             36*(Atu12*PDstandard4th1phi + Atu22*PDstandard4th2phi + Atu23*PDstandard4th3phi)) + 
+          gtu23*(16*PDstandard4th23beta2 + 4*PDstandard4th33beta3 - 4*alphaL*PDstandard4th3trK));
+    
+    Xt3rhsL  =  kthird*(-3*(beta1L*(ddgtu1311 + ddgtu2321 + ddgtu3331) + beta2L*(ddgtu1321 + ddgtu2322 + ddgtu3332) + 
+             beta3L*(ddgtu1331 + ddgtu2332 + ddgtu3333)) + 12*gtu12*PDstandard4th12beta3 + 
+          (dgtu131 - 2*(dgtu232 + dgtu333))*PDstandard4th1beta1 + (6*dgtu122 + 9*dgtu133)*PDstandard4th1beta3 + 
+          gtu13*(16*PDstandard4th13beta3 - 4*alphaL*PDstandard4th1trK) + 
+          (dgtu232 - 2*(dgtu131 + dgtu333))*PDstandard4th2beta2 + (6*dgtu222 + 9*dgtu233)*PDstandard4th2beta3 + 
+          6*(gtu11*PDstandard4th11beta3 + dgtu111*PDstandard4th1beta3 + gtu22*PDstandard4th22beta3 + 
+             dgtu121*PDstandard4th2beta3) + gtu23*(16*PDstandard4th23beta3 - 4*alphaL*PDstandard4th2trK) - 
+          6*(Atu13*PDstandard4th1alpha + Atu23*PDstandard4th2alpha + Atu33*PDstandard4th3alpha) + 
+          3*(dgtu132*PDstandard4th1beta2 + dgtu231*PDstandard4th2beta1 + dgtu331*PDstandard4th3beta1 + 
+             dgtu332*PDstandard4th3beta2) + (4*dgtu232 + 7*dgtu333)*PDstandard4th3beta3 + 
+          4*(gtu13*(PDstandard4th11beta1 + PDstandard4th12beta2) + gtu23*(PDstandard4th12beta1 + PDstandard4th22beta2) + 
+             gtu33*(PDstandard4th13beta1 + PDstandard4th23beta2) + dgtu131*PDstandard4th3beta3) + 
+          alphaL*(12*(Atu12*Gt321 + Atu13*Gt331 + Atu23*Gt332) + 6*(Atu11*Gt311 + Atu22*Gt322 + Atu33*Gt333) + 
+             36*(Atu13*PDstandard4th1phi + Atu23*PDstandard4th2phi + Atu33*PDstandard4th3phi)) + 
+          gtu33*(10*PDstandard4th33beta3 - 4*alphaL*PDstandard4th3trK));
+    
+    trKrhsL  =  -(gu11*PDstandard4th11alpha) - 2*gu12*PDstandard4th12alpha - 2*gu13*PDstandard4th13alpha + 
+        (G111*gu11 + 2*G121*gu12 + 2*G131*gu13 + G122*gu22 + 2*G132*gu23 + G133*gu33)*PDstandard4th1alpha + 
+        beta1L*PDstandard4th1trK - gu22*PDstandard4th22alpha - 2*gu23*PDstandard4th23alpha + 
+        (G211*gu11 + 2*G221*gu12 + 2*G231*gu13 + G222*gu22 + 2*G232*gu23 + G233*gu33)*PDstandard4th2alpha + 
+        beta2L*PDstandard4th2trK - gu33*PDstandard4th33alpha + G311*gu11*PDstandard4th3alpha + 
+        2*G331*gu13*PDstandard4th3alpha + G322*gu22*PDstandard4th3alpha + 2*G332*gu23*PDstandard4th3alpha + 
+        G333*gu33*PDstandard4th3alpha + 2*(alphaL*Atm12*Atm21 + alphaL*Atm13*Atm31 + alphaL*Atm23*Atm32 + 
+           G321*gu12*PDstandard4th3alpha) + beta3L*PDstandard4th3trK + alphaL*SQR(Atm11) + alphaL*SQR(Atm22) + 
+        alphaL*SQR(Atm33) + alphaL*kthird*SQR(trKL);
+    
+    At11rhsL  =  beta1L*PDstandard4th1At11 + 2*(At11L*PDstandard4th1beta1 + At21L*PDstandard4th1beta2 + 
+           At31L*PDstandard4th1beta3) + beta2L*PDstandard4th2At11 + beta3L*PDstandard4th3At11 - 
+        At11L*ktwothird*(PDstandard4th1beta1 + PDstandard4th2beta2 + PDstandard4th3beta3) - 
+        em4phi*kthird*(3*PDstandard4th11alpha - g11*gu11*PDstandard4th11alpha - 2*g11*gu12*PDstandard4th12alpha - 
+           2*g11*gu13*PDstandard4th13alpha + (G111*(-3 + g11*gu11) + 
+              g11*(2*G121*gu12 + 2*G131*gu13 + G122*gu22 + 2*G132*gu23 + G133*gu33))*PDstandard4th1alpha - 
+           g11*gu22*PDstandard4th22alpha - 2*g11*gu23*PDstandard4th23alpha + 
+           (G211*(-3 + g11*gu11) + g11*(2*G221*gu12 + 2*G231*gu13 + G222*gu22 + 2*G232*gu23 + G233*gu33))*
+            PDstandard4th2alpha - g11*gu33*PDstandard4th33alpha - 3*G311*PDstandard4th3alpha + 
+           g11*G311*gu11*PDstandard4th3alpha + 2*g11*G321*gu12*PDstandard4th3alpha + 2*g11*G331*gu13*PDstandard4th3alpha + 
+           g11*G322*gu22*PDstandard4th3alpha + 2*g11*G332*gu23*PDstandard4th3alpha + g11*G333*gu33*PDstandard4th3alpha - 
+           3*alphaL*R11 + alphaL*g11*gu11*R11 + 2*alphaL*g11*gu12*R21 + alphaL*g11*gu22*R22 + 2*alphaL*g11*gu13*R31 + 
+           2*alphaL*g11*gu23*R32 + alphaL*g11*gu33*R33) + alphaL*(-2*(At11L*Atm11 + At21L*Atm21 + At31L*Atm31) + At11L*trKL);
+    
+    At21rhsL  =  beta1L*PDstandard4th1At21 + At22L*PDstandard4th1beta2 + At32L*PDstandard4th1beta3 + 
+        beta2L*PDstandard4th2At21 + At11L*PDstandard4th2beta1 + At31L*PDstandard4th2beta3 + beta3L*PDstandard4th3At21 + 
+        At21L*(PDstandard4th1beta1 + PDstandard4th2beta2 - 
+           ktwothird*(PDstandard4th1beta1 + PDstandard4th2beta2 + PDstandard4th3beta3)) - 
+        em4phi*kthird*(3*PDstandard4th12alpha + (G121*(-3 + 2*g21*gu12) + 
+              g21*(G111*gu11 + G122*gu22 + 2*(G131*gu13 + G132*gu23) + G133*gu33))*PDstandard4th1alpha + 
+           (G221*(-3 + 2*g21*gu12) + g21*(G211*gu11 + G222*gu22 + 2*(G231*gu13 + G232*gu23) + G233*gu33))*
+            PDstandard4th2alpha + G321*(-3 + 2*g21*gu12)*PDstandard4th3alpha + 
+           alphaL*(-3*R21 + g21*(gu22*R22 + 2*gu23*R32)) + 
+           g21*(-(gu11*PDstandard4th11alpha) - 2*gu12*PDstandard4th12alpha - 2*gu13*PDstandard4th13alpha - 
+              gu22*PDstandard4th22alpha - 2*gu23*PDstandard4th23alpha - gu33*PDstandard4th33alpha + 
+              G311*gu11*PDstandard4th3alpha + 2*G331*gu13*PDstandard4th3alpha + G322*gu22*PDstandard4th3alpha + 
+              2*G332*gu23*PDstandard4th3alpha + G333*gu33*PDstandard4th3alpha + alphaL*gu11*R11 + 2*alphaL*gu12*R21 + 
+              2*alphaL*gu13*R31 + alphaL*gu33*R33)) + alphaL*(-2*(At11L*Atm12 + At21L*Atm22 + At31L*Atm32) + At21L*trKL);
+    
+    At31rhsL  =  beta1L*PDstandard4th1At31 + At32L*PDstandard4th1beta2 + At33L*PDstandard4th1beta3 + 
+        beta2L*PDstandard4th2At31 + beta3L*PDstandard4th3At31 + At11L*PDstandard4th3beta1 + At21L*PDstandard4th3beta2 + 
+        At31L*(PDstandard4th1beta1 + PDstandard4th3beta3 - 
+           ktwothird*(PDstandard4th1beta1 + PDstandard4th2beta2 + PDstandard4th3beta3)) - 
+        em4phi*kthird*(3*PDstandard4th13alpha + (G131*(-3 + 2*g31*gu13) + 
+              g31*(G111*gu11 + G122*gu22 + 2*(G121*gu12 + G132*gu23) + G133*gu33))*PDstandard4th1alpha + 
+           (G231*(-3 + 2*g31*gu13) + g31*(G211*gu11 + G222*gu22 + 2*(G221*gu12 + G232*gu23) + G233*gu33))*
+            PDstandard4th2alpha + (G331*(-3 + 2*g31*gu13) + g31*(G322*gu22 + 2*(G321*gu12 + G332*gu23) + G333*gu33))*
+            PDstandard4th3alpha + alphaL*(-3*R31 + 2*g31*gu23*R32) + 
+           g31*(-(gu11*PDstandard4th11alpha) - 2*gu12*PDstandard4th12alpha - 2*gu13*PDstandard4th13alpha - 
+              gu22*PDstandard4th22alpha - 2*gu23*PDstandard4th23alpha - gu33*PDstandard4th33alpha + 
+              G311*gu11*PDstandard4th3alpha + alphaL*gu11*R11 + 2*alphaL*gu12*R21 + alphaL*gu22*R22 + 2*alphaL*gu13*R31 + 
+              alphaL*gu33*R33)) + alphaL*(-2*(At11L*Atm13 + At21L*Atm23 + At31L*Atm33) + At31L*trKL);
+    
+    At22rhsL  =  beta1L*PDstandard4th1At22 + beta2L*PDstandard4th2At22 + 
+        2*(At21L*PDstandard4th2beta1 + At22L*PDstandard4th2beta2 + At32L*PDstandard4th2beta3) + beta3L*PDstandard4th3At22 - 
+        At22L*ktwothird*(PDstandard4th1beta1 + PDstandard4th2beta2 + PDstandard4th3beta3) - 
+        em4phi*kthird*(-(g22*gu11*PDstandard4th11alpha) - 2*g22*gu12*PDstandard4th12alpha - 
+           2*g22*gu13*PDstandard4th13alpha + (G122*(-3 + g22*gu22) + 
+              g22*(G111*gu11 + 2*G121*gu12 + 2*G131*gu13 + 2*G132*gu23 + G133*gu33))*PDstandard4th1alpha + 
+           3*PDstandard4th22alpha - g22*gu22*PDstandard4th22alpha - 2*g22*gu23*PDstandard4th23alpha + 
+           (G222*(-3 + g22*gu22) + g22*(G211*gu11 + 2*G221*gu12 + 2*G231*gu13 + 2*G232*gu23 + G233*gu33))*
+            PDstandard4th2alpha - g22*gu33*PDstandard4th33alpha - 3*G322*PDstandard4th3alpha + 
+           g22*G311*gu11*PDstandard4th3alpha + 2*g22*G321*gu12*PDstandard4th3alpha + 2*g22*G331*gu13*PDstandard4th3alpha + 
+           g22*G322*gu22*PDstandard4th3alpha + 2*g22*G332*gu23*PDstandard4th3alpha + g22*G333*gu33*PDstandard4th3alpha + 
+           alphaL*g22*gu11*R11 + 2*alphaL*g22*gu12*R21 - 3*alphaL*R22 + alphaL*g22*gu22*R22 + 2*alphaL*g22*gu13*R31 + 
+           2*alphaL*g22*gu23*R32 + alphaL*g22*gu33*R33) + alphaL*(-2*(At21L*Atm12 + At22L*Atm22 + At32L*Atm32) + At22L*trKL);
+    
+    At32rhsL  =  beta1L*PDstandard4th1At32 + beta2L*PDstandard4th2At32 + At31L*PDstandard4th2beta1 + 
+        At33L*PDstandard4th2beta3 + beta3L*PDstandard4th3At32 + At21L*PDstandard4th3beta1 + At22L*PDstandard4th3beta2 + 
+        At32L*(PDstandard4th2beta2 + PDstandard4th3beta3 - 
+           ktwothird*(PDstandard4th1beta1 + PDstandard4th2beta2 + PDstandard4th3beta3)) - 
+        em4phi*kthird*((G132*(-3 + 2*g32*gu23) + g32*(G111*gu11 + 2*(G121*gu12 + G131*gu13) + G122*gu22 + G133*gu33))*
+            PDstandard4th1alpha + 3*PDstandard4th23alpha + 
+           (G232*(-3 + 2*g32*gu23) + g32*(G211*gu11 + 2*(G221*gu12 + G231*gu13) + G222*gu22 + G233*gu33))*
+            PDstandard4th2alpha + (G332*(-3 + 2*g32*gu23) + g32*(2*(G321*gu12 + G331*gu13) + G322*gu22 + G333*gu33))*
+            PDstandard4th3alpha + g32*(-(gu11*PDstandard4th11alpha) - 2*gu12*PDstandard4th12alpha - 
+              2*gu13*PDstandard4th13alpha - gu22*PDstandard4th22alpha - 2*gu23*PDstandard4th23alpha - 
+              gu33*PDstandard4th33alpha + G311*gu11*PDstandard4th3alpha + alphaL*gu11*R11 + 2*alphaL*gu12*R21 + 
+              alphaL*gu22*R22 + 2*alphaL*gu13*R31 + 2*alphaL*gu23*R32) + alphaL*(-3*R32 + g32*gu33*R33)) + 
+        alphaL*(-2*(At21L*Atm13 + At22L*Atm23 + At32L*Atm33) + At32L*trKL);
+    
+    At33rhsL  =  beta1L*PDstandard4th1At33 + beta2L*PDstandard4th2At33 + beta3L*PDstandard4th3At33 - 
+        At33L*ktwothird*(PDstandard4th1beta1 + PDstandard4th2beta2 + PDstandard4th3beta3) + 
+        2*(At31L*PDstandard4th3beta1 + At32L*PDstandard4th3beta2 + At33L*PDstandard4th3beta3) - 
+        em4phi*kthird*(-(g33*gu11*PDstandard4th11alpha) - 2*g33*gu12*PDstandard4th12alpha - 
+           2*g33*gu13*PDstandard4th13alpha + (g33*(G111*gu11 + 2*G121*gu12 + 2*G131*gu13 + G122*gu22 + 2*G132*gu23) + 
+              G133*(-3 + g33*gu33))*PDstandard4th1alpha - g33*gu22*PDstandard4th22alpha - 2*g33*gu23*PDstandard4th23alpha + 
+           (g33*(G211*gu11 + 2*G221*gu12 + 2*G231*gu13 + G222*gu22 + 2*G232*gu23) + G233*(-3 + g33*gu33))*
+            PDstandard4th2alpha + 3*PDstandard4th33alpha - g33*gu33*PDstandard4th33alpha - 3*G333*PDstandard4th3alpha + 
+           G311*g33*gu11*PDstandard4th3alpha + 2*G321*g33*gu12*PDstandard4th3alpha + 2*g33*G331*gu13*PDstandard4th3alpha + 
+           G322*g33*gu22*PDstandard4th3alpha + 2*g33*G332*gu23*PDstandard4th3alpha + g33*G333*gu33*PDstandard4th3alpha + 
+           alphaL*g33*gu11*R11 + 2*alphaL*g33*gu12*R21 + alphaL*g33*gu22*R22 + 2*alphaL*g33*gu13*R31 + 
+           2*alphaL*g33*gu23*R32 - 3*alphaL*R33 + alphaL*g33*gu33*R33) + 
+        alphaL*(-2*(At31L*Atm13 + At32L*Atm23 + At33L*Atm33) + At33L*trKL);
+    
+    alpharhsL  =  beta1L*PDstandard4th1alpha + beta2L*PDstandard4th2alpha + beta3L*PDstandard4th3alpha;
+    
+    dtalpharhsL  =  beta1L*PDstandard4th1dtalpha + beta2L*PDstandard4th2dtalpha + beta3L*PDstandard4th3dtalpha;
+    
+    beta1rhsL  =  0;
+    
+    beta2rhsL  =  0;
+    
+    beta3rhsL  =  0;
+    
+    dtbeta1rhsL  =  -(dtbeta1L*PDstandard4th1beta1) + beta1L*PDstandard4th1dtbeta1 - dtbeta2L*PDstandard4th2beta1 + 
+        beta2L*PDstandard4th2dtbeta1 - dtbeta3L*PDstandard4th3beta1 + beta3L*PDstandard4th3dtbeta1;
+    
+    dtbeta2rhsL  =  -(dtbeta1L*PDstandard4th1beta2) + beta1L*PDstandard4th1dtbeta2 - dtbeta2L*PDstandard4th2beta2 + 
+        beta2L*PDstandard4th2dtbeta2 - dtbeta3L*PDstandard4th3beta2 + beta3L*PDstandard4th3dtbeta2;
+    
+    dtbeta3rhsL  =  -(dtbeta1L*PDstandard4th1beta3) + beta1L*PDstandard4th1dtbeta3 - dtbeta2L*PDstandard4th2beta3 + 
+        beta2L*PDstandard4th2dtbeta3 - dtbeta3L*PDstandard4th3beta3 + beta3L*PDstandard4th3dtbeta3;
+    
+    
+    /* Copy local copies back to grid functions */
+    alpharhs[index] = alpharhsL;
+    At11rhs[index] = At11rhsL;
+    At21rhs[index] = At21rhsL;
+    At22rhs[index] = At22rhsL;
+    At31rhs[index] = At31rhsL;
+    At32rhs[index] = At32rhsL;
+    At33rhs[index] = At33rhsL;
+    beta1rhs[index] = beta1rhsL;
+    beta2rhs[index] = beta2rhsL;
+    beta3rhs[index] = beta3rhsL;
+    dtalpharhs[index] = dtalpharhsL;
+    dtbeta1rhs[index] = dtbeta1rhsL;
+    dtbeta2rhs[index] = dtbeta2rhsL;
+    dtbeta3rhs[index] = dtbeta3rhsL;
+    gt11rhs[index] = gt11rhsL;
+    gt21rhs[index] = gt21rhsL;
+    gt22rhs[index] = gt22rhsL;
+    gt31rhs[index] = gt31rhsL;
+    gt32rhs[index] = gt32rhsL;
+    gt33rhs[index] = gt33rhsL;
+    phirhs[index] = phirhsL;
+    trKrhs[index] = trKrhsL;
+    Xt1rhs[index] = Xt1rhsL;
+    Xt2rhs[index] = Xt2rhsL;
+    Xt3rhs[index] = Xt3rhsL;
+    
+    /* Copy local copies back to subblock grid functions */
+  }
+  LC_ENDLOOP3 (somename);
+}
+
+void ML_BSSN_RHS(CCTK_ARGUMENTS)
+{
+  DECLARE_CCTK_ARGUMENTS
+  DECLARE_CCTK_PARAMETERS
+  
+  GenericFD_LoopOverInterior(cctkGH, &ML_BSSN_RHS_Body);
+}
diff --git a/ML_BSSN/src/ML_BSSN_constraints.c b/ML_BSSN/src/ML_BSSN_constraints.c
index 454745d..f818a2e 100644
--- a/ML_BSSN/src/ML_BSSN_constraints.c
+++ b/ML_BSSN/src/ML_BSSN_constraints.c
@@ -371,22 +371,13 @@ void ML_BSSN_constraints_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REA
     /* Precompute derivatives (old style) */
     
     /* Calculate temporaries and grid functions */
-    detgt  =  2*gt21L*gt31L*gt32L + gt33L*(gt11L*gt22L - SQR(gt21L)) - gt22L*SQR(gt31L) - gt11L*SQR(gt32L);
-    
-    ddetgt1  =  (-2*gt22L*gt31L + 2*gt21L*gt32L)*PDstandard4th1gt31 + 
-        2*((gt31L*gt32L - gt21L*gt33L)*PDstandard4th1gt21 + (gt21L*gt31L - gt11L*gt32L)*PDstandard4th1gt32) + 
-        PDstandard4th1gt33*(gt11L*gt22L - SQR(gt21L)) + PDstandard4th1gt22*(gt11L*gt33L - SQR(gt31L)) + 
-        PDstandard4th1gt11*(gt22L*gt33L - SQR(gt32L));
-    
-    ddetgt2  =  (-2*gt22L*gt31L + 2*gt21L*gt32L)*PDstandard4th2gt31 + 
-        2*((gt31L*gt32L - gt21L*gt33L)*PDstandard4th2gt21 + (gt21L*gt31L - gt11L*gt32L)*PDstandard4th2gt32) + 
-        PDstandard4th2gt33*(gt11L*gt22L - SQR(gt21L)) + PDstandard4th2gt22*(gt11L*gt33L - SQR(gt31L)) + 
-        PDstandard4th2gt11*(gt22L*gt33L - SQR(gt32L));
-    
-    ddetgt3  =  (-2*gt22L*gt31L + 2*gt21L*gt32L)*PDstandard4th3gt31 + 
-        2*((gt31L*gt32L - gt21L*gt33L)*PDstandard4th3gt21 + (gt21L*gt31L - gt11L*gt32L)*PDstandard4th3gt32) + 
-        PDstandard4th3gt33*(gt11L*gt22L - SQR(gt21L)) + PDstandard4th3gt22*(gt11L*gt33L - SQR(gt31L)) + 
-        PDstandard4th3gt11*(gt22L*gt33L - SQR(gt32L));
+    detgt  =  1;
+    
+    ddetgt1  =  0;
+    
+    ddetgt2  =  0;
+    
+    ddetgt3  =  0;
     
     gtu11  =  INV(detgt)*(gt22L*gt33L - SQR(gt32L));
     
diff --git a/ML_BSSN/src/ML_BSSN_convertFromADMBaseGamma.c b/ML_BSSN/src/ML_BSSN_convertFromADMBaseGamma.c
index 0dc3bfe..32b4fc8 100644
--- a/ML_BSSN/src/ML_BSSN_convertFromADMBaseGamma.c
+++ b/ML_BSSN/src/ML_BSSN_convertFromADMBaseGamma.c
@@ -160,7 +160,7 @@ void ML_BSSN_convertFromADMBaseGamma_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT fa
     /* Precompute derivatives (old style) */
     
     /* Calculate temporaries and grid functions */
-    detgt  =  2*gt21L*gt31L*gt32L + gt33L*(gt11L*gt22L - SQR(gt21L)) - gt22L*SQR(gt31L) - gt11L*SQR(gt32L);
+    detgt  =  1;
     
     gtu11  =  INV(detgt)*(gt22L*gt33L - SQR(gt32L));
     
diff --git a/ML_BSSN/src/ML_BSSN_enforce.c b/ML_BSSN/src/ML_BSSN_enforce.c
index 9442ff9..5d75422 100644
--- a/ML_BSSN/src/ML_BSSN_enforce.c
+++ b/ML_BSSN/src/ML_BSSN_enforce.c
@@ -128,7 +128,7 @@ void ML_BSSN_enforce_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL no
     /* Precompute derivatives (old style) */
     
     /* Calculate temporaries and grid functions */
-    detgt  =  2*gt21L*gt31L*gt32L + gt33L*(gt11L*gt22L - SQR(gt21L)) - gt22L*SQR(gt31L) - gt11L*SQR(gt32L);
+    detgt  =  1;
     
     gtu11  =  INV(detgt)*(gt22L*gt33L - SQR(gt32L));
     
diff --git a/ML_BSSN/src/RegisterMoL.c b/ML_BSSN/src/RegisterMoL.c
index 8154e5f..b0051a5 100644
--- a/ML_BSSN/src/RegisterMoL.c
+++ b/ML_BSSN/src/RegisterMoL.c
@@ -15,5 +15,30 @@ void ML_BSSN_RegisterVars(CCTK_ARGUMENTS)
   CCTK_INT ierr = 0;
   
   /* Register all the evolved grid functions with MoL */
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::At11"),  CCTK_VarIndex("ML_BSSN::At11rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::At21"),  CCTK_VarIndex("ML_BSSN::At21rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::At31"),  CCTK_VarIndex("ML_BSSN::At31rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::At22"),  CCTK_VarIndex("ML_BSSN::At22rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::At32"),  CCTK_VarIndex("ML_BSSN::At32rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::At33"),  CCTK_VarIndex("ML_BSSN::At33rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::dtalpha"),  CCTK_VarIndex("ML_BSSN::dtalpharhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::dtbeta1"),  CCTK_VarIndex("ML_BSSN::dtbeta1rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::dtbeta2"),  CCTK_VarIndex("ML_BSSN::dtbeta2rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::dtbeta3"),  CCTK_VarIndex("ML_BSSN::dtbeta3rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::Xt1"),  CCTK_VarIndex("ML_BSSN::Xt1rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::Xt2"),  CCTK_VarIndex("ML_BSSN::Xt2rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::Xt3"),  CCTK_VarIndex("ML_BSSN::Xt3rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::alpha"),  CCTK_VarIndex("ML_BSSN::alpharhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::phi"),  CCTK_VarIndex("ML_BSSN::phirhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::gt11"),  CCTK_VarIndex("ML_BSSN::gt11rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::gt21"),  CCTK_VarIndex("ML_BSSN::gt21rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::gt31"),  CCTK_VarIndex("ML_BSSN::gt31rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::gt22"),  CCTK_VarIndex("ML_BSSN::gt22rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::gt32"),  CCTK_VarIndex("ML_BSSN::gt32rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::gt33"),  CCTK_VarIndex("ML_BSSN::gt33rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::beta1"),  CCTK_VarIndex("ML_BSSN::beta1rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::beta2"),  CCTK_VarIndex("ML_BSSN::beta2rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::beta3"),  CCTK_VarIndex("ML_BSSN::beta3rhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_BSSN::trK"),  CCTK_VarIndex("ML_BSSN::trKrhs"));
   return;
 }
diff --git a/ML_BSSN/src/RegisterSymmetries.c b/ML_BSSN/src/RegisterSymmetries.c
index 6ca48f8..2db5dee 100644
--- a/ML_BSSN/src/RegisterSymmetries.c
+++ b/ML_BSSN/src/RegisterSymmetries.c
@@ -22,31 +22,6 @@ void ML_BSSN_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cS");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt1");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt2");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt3");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cA");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
   SetCartSymVN(cctkGH, sym, "ML_BSSN::At11");
   
   sym[0] = -1;
@@ -112,11 +87,6 @@ void ML_BSSN_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::H");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
   SetCartSymVN(cctkGH, sym, "ML_BSSN::alpha");
   
   sym[0] = 1;
@@ -157,36 +127,66 @@ void ML_BSSN_RegisterSymmetries(CCTK_ARGUMENTS)
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::M1");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::beta1");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::M2");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::beta2");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::M3");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::beta3");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::trK");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::cS");
   
   sym[0] = -1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::beta1");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt1");
   
   sym[0] = 1;
   sym[1] = -1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::beta2");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt2");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::beta3");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt3");
   
   sym[0] = 1;
   sym[1] = 1;
   sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::trK");
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::cA");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::H");
+  
+  sym[0] = -1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::M1");
+  
+  sym[0] = 1;
+  sym[1] = -1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::M2");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = -1;
+  SetCartSymVN(cctkGH, sym, "ML_BSSN::M3");
   
 }
diff --git a/ML_BSSN/src/make.code.defn b/ML_BSSN/src/make.code.defn
index 3aa081e..730942f 100644
--- a/ML_BSSN/src/make.code.defn
+++ b/ML_BSSN/src/make.code.defn
@@ -3,4 +3,4 @@
 
 # Mathematica script written by Ian Hinder and Sascha Husa
 
-SRCS = Startup.c RegisterMoL.c RegisterSymmetries.c ML_BSSN_Minkowski.c ML_BSSN_convertFromADMBase.c ML_BSSN_convertFromADMBaseGamma.c ML_BSSN_enforce.c ML_BSSN_convertToADMBase.c ML_BSSN_constraints.c Boundaries.c 
+SRCS = Startup.c RegisterMoL.c RegisterSymmetries.c ML_BSSN_Minkowski.c ML_BSSN_convertFromADMBase.c ML_BSSN_convertFromADMBaseGamma.c ML_BSSN_RHS.c ML_BSSN_enforce.c ML_BSSN_convertToADMBase.c ML_BSSN_constraints.c Boundaries.c 
diff --git a/m/ML_ADM/configuration.ccl b/m/ML_ADM/configuration.ccl
deleted file mode 100644
index 0374af4..0000000
--- a/m/ML_ADM/configuration.ccl
+++ /dev/null
@@ -1,6 +0,0 @@
-# File produced by user eschnett
-# Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007)
-
-# Mathematica script written by Ian Hinder and Sascha Husa
-
-REQUIRES LoopControl
diff --git a/m/ML_ADM/interface.ccl b/m/ML_ADM/interface.ccl
deleted file mode 100644
index c3fae86..0000000
--- a/m/ML_ADM/interface.ccl
+++ /dev/null
@@ -1,117 +0,0 @@
-# File produced by user eschnett
-# Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007)
-
-# Mathematica script written by Ian Hinder and Sascha Husa
-
-implements: ML_ADM
-
-inherits:   ADMBase Grid GenericFD Boundary
-
-
-
-USES INCLUDE: GenericFD.h
-USES INCLUDE: Symmetry.h
-USES INCLUDE: sbp_calc_coeffs.h
-USES INCLUDE: Boundary.h
-USES INCLUDE: loopcontrol.h
-
-CCTK_INT FUNCTION MoLRegisterEvolved(CCTK_INT IN EvolvedIndex, CCTK_INT IN RHSIndex)
-USES FUNCTION MoLRegisterEvolved
-
-CCTK_INT FUNCTION MoLRegisterConstrained(CCTK_INT IN ConstrainedIndex)
-USES FUNCTION MoLRegisterConstrained
-
-SUBROUTINE Diff_coeff(CCTK_POINTER_TO_CONST IN cctkGH, CCTK_INT IN dir, CCTK_INT IN nsize, CCTK_INT OUT ARRAY imin, CCTK_INT OUT ARRAY imax, CCTK_REAL OUT ARRAY q, CCTK_INT IN table_handle)
-USES FUNCTION Diff_coeff
-
-CCTK_INT FUNCTION Boundary_SelectGroupForBC(CCTK_POINTER_TO_CONST IN GH, CCTK_INT IN faces, CCTK_INT IN boundary_width, CCTK_INT IN table_handle, CCTK_STRING IN group_name, CCTK_STRING IN bc_name)
-USES FUNCTION Boundary_SelectGroupForBC
-
-CCTK_INT FUNCTION Boundary_SelectVarForBC(CCTK_POINTER_TO_CONST IN GH, CCTK_INT IN faces, CCTK_INT IN boundary_width, CCTK_INT IN table_handle, CCTK_STRING IN var_name, CCTK_STRING IN bc_name)
-USES FUNCTION Boundary_SelectVarForBC
-
-public:
-CCTK_REAL Ham type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  H
-} "Ham"
-
-public:
-CCTK_REAL mom type=GF timelevels=1 tags='tensortypealias="D" tensorweight=1.0000000000000000000'
-{
-  M1,
-  M2,
-  M3
-} "mom"
-
-public:
-CCTK_REAL curvrhs type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
-{
-  K11rhs,
-  K21rhs,
-  K31rhs,
-  K22rhs,
-  K32rhs,
-  K33rhs
-} "curvrhs"
-
-public:
-CCTK_REAL lapserhs type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  alpharhs
-} "lapserhs"
-
-public:
-CCTK_REAL metricrhs type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
-{
-  g11rhs,
-  g21rhs,
-  g31rhs,
-  g22rhs,
-  g32rhs,
-  g33rhs
-} "metricrhs"
-
-public:
-CCTK_REAL shiftrhs type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
-{
-  beta1rhs,
-  beta2rhs,
-  beta3rhs
-} "shiftrhs"
-
-public:
-CCTK_REAL curv type=GF timelevels=3 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
-{
-  K11,
-  K21,
-  K31,
-  K22,
-  K32,
-  K33
-} "curv"
-
-public:
-CCTK_REAL lapse type=GF timelevels=3 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  alpha
-} "lapse"
-
-public:
-CCTK_REAL metric type=GF timelevels=3 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
-{
-  g11,
-  g21,
-  g31,
-  g22,
-  g32,
-  g33
-} "metric"
-
-public:
-CCTK_REAL shift type=GF timelevels=3 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
-{
-  beta1,
-  beta2,
-  beta3
-} "shift"
diff --git a/m/ML_ADM/param.ccl b/m/ML_ADM/param.ccl
deleted file mode 100644
index 71c2edb..0000000
--- a/m/ML_ADM/param.ccl
+++ /dev/null
@@ -1,710 +0,0 @@
-# File produced by user eschnett
-# Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007)
-
-# Mathematica script written by Ian Hinder and Sascha Husa
-
-
-shares: ADMBase
-
-USES CCTK_KEYWORD initial_data
-
-
-shares: GenericFD
-
-USES CCTK_INT stencil_width
-USES CCTK_INT stencil_width_x
-USES CCTK_INT stencil_width_y
-USES CCTK_INT stencil_width_z
-USES CCTK_INT boundary_width
-
-
-shares: MethodOfLines
-
-USES CCTK_INT MoL_Num_Evolved_Vars
-USES CCTK_INT MoL_Num_Constrained_Vars
-
-restricted:
-CCTK_REAL verbose "verbose"
-{
-  "*:*" :: "no restrictions"
-} 0
-
-private:
-KEYWORD my_initial_data "my_initial_data"
-{
-  "ADMBase" :: "ADMBase"
-  "Minkowski" :: "Minkowski"
-} "ADMBase"
-
-restricted:
-CCTK_INT ML_ADM_MaxNumEvolvedVars "Number of evolved variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_Evolved_Vars
-{
-  16:16 :: "Number of evolved variables used by this thorn"
-} 16
-
-restricted:
-CCTK_INT ML_ADM_MaxNumConstrainedVars "Number of constrained variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_Constrained_Vars
-{
-  28:28 :: "Number of constrained variables used by this thorn"
-} 28
-
-restricted:
-CCTK_INT ML_ADM_Minkowski_calc_every "ML_ADM_Minkowski_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_ADM_convertFromADMBase_calc_every "ML_ADM_convertFromADMBase_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_ADM_RHS_calc_every "ML_ADM_RHS_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_ADM_convertToADMBase_calc_every "ML_ADM_convertToADMBase_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_ADM_constraints_calc_every "ML_ADM_constraints_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_ADM_Minkowski_calc_offset "ML_ADM_Minkowski_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
-restricted:
-CCTK_INT ML_ADM_convertFromADMBase_calc_offset "ML_ADM_convertFromADMBase_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
-restricted:
-CCTK_INT ML_ADM_RHS_calc_offset "ML_ADM_RHS_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
-restricted:
-CCTK_INT ML_ADM_convertToADMBase_calc_offset "ML_ADM_convertToADMBase_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
-restricted:
-CCTK_INT ML_ADM_constraints_calc_offset "ML_ADM_constraints_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
-private:
-KEYWORD K11_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD K21_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD K31_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD K22_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD K32_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD K33_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD alpha_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD g11_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD g21_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD g31_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD g22_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD g32_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD g33_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD beta1_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD beta2_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD beta3_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD curv_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD lapse_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD metric_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-KEYWORD shift_bound "Boundary condition to implement"
-{
-  "flat" :: "Flat boundary condition"
-  "none" :: "No boundary condition"
-  "static" :: "Boundaries held fixed"
-  "radiative" :: "Radiation boundary condition"
-  "scalar" :: "Dirichlet boundary condition"
-  "newrad" :: "Improved radiative boundary condition"
-  "skip" :: "skip boundary condition code"
-} "skip"
-
-private:
-CCTK_REAL K11_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL K21_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL K31_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL K22_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL K32_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL K33_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL alpha_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL g11_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL g21_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL g31_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL g22_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL g32_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL g33_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL beta1_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL beta2_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL beta3_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL curv_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL lapse_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL metric_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL shift_bound_speed "characteristic speed at boundary"
-{
-  "0:*" :: "outgoing characteristic speed > 0"
-} 1.
-
-private:
-CCTK_REAL K11_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL K21_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL K31_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL K22_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL K32_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL K33_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL alpha_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL g11_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL g21_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL g31_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL g22_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL g32_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL g33_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL beta1_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL beta2_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL beta3_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL curv_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL lapse_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL metric_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL shift_bound_limit "limit value for r -> infinity"
-{
-  "*:*" :: "value of limit value is unrestricted"
-} 0.
-
-private:
-CCTK_REAL K11_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL K21_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL K31_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL K22_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL K32_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL K33_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL alpha_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL g11_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL g21_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL g31_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL g22_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL g32_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL g33_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL beta1_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL beta2_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL beta3_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL curv_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL lapse_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL metric_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
-private:
-CCTK_REAL shift_bound_scalar "Dirichlet boundary value"
-{
-  "*:*" :: "unrestricted"
-} 0.
-
diff --git a/m/ML_ADM/schedule.ccl b/m/ML_ADM/schedule.ccl
deleted file mode 100644
index 01a6f4d..0000000
--- a/m/ML_ADM/schedule.ccl
+++ /dev/null
@@ -1,121 +0,0 @@
-# File produced by user eschnett
-# Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007)
-
-# Mathematica script written by Ian Hinder and Sascha Husa
-
-
-STORAGE: Ham[1]
-
-STORAGE: mom[1]
-
-STORAGE: curvrhs[1]
-
-STORAGE: lapserhs[1]
-
-STORAGE: metricrhs[1]
-
-STORAGE: shiftrhs[1]
-
-STORAGE: curv[3]
-
-STORAGE: lapse[3]
-
-STORAGE: metric[3]
-
-STORAGE: shift[3]
-
-schedule ML_ADM_Startup at STARTUP
-{
-  LANG: C
-  OPTIONS: meta
-} "create banner"
-
-schedule ML_ADM_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
-schedule ML_ADM_RegisterSymmetries at BASEGRID
-{
-  LANG: C
-  OPTIONS: meta
-} "register symmetries"
-
-
-if (CCTK_EQUALS(my_initial_data, "Minkowski"))
-{
-  schedule ML_ADM_Minkowski IN ADMBase_InitialData
-  {
-    LANG: C
-    
-  } "ML_ADM_Minkowski"
-}
-
-
-if (CCTK_EQUALS(my_initial_data, "ADMBase"))
-{
-  schedule ML_ADM_convertFromADMBase AT initial
-  {
-    LANG: C
-    
-  } "ML_ADM_convertFromADMBase"
-}
-
-
-if (CCTK_EQUALS(my_initial_data, "ADMBase"))
-{
-  schedule ML_ADM_convertFromADMBase AFTER ADMBase_PostInitial
-  {
-    LANG: C
-    
-  } "ML_ADM_convertFromADMBase"
-}
-
-schedule ML_ADM_RHS IN MoL_CalcRHS
-{
-  LANG: C
-  
-} "ML_ADM_RHS"
-
-schedule ML_ADM_convertToADMBase IN MoL_PostStep
-{
-  LANG: C
-  
-} "ML_ADM_convertToADMBase"
-
-schedule ML_ADM_convertToADMBase AFTER ADM_ApplyBoundConds
-{
-  LANG: C
-  
-} "ML_ADM_convertToADMBase"
-
-schedule ML_ADM_constraints AT analysis
-{
-  LANG: C
-  
-  SYNC: Ham
-  SYNC: mom
-} "ML_ADM_constraints"
-
-schedule ML_ADM_ApplyBoundConds in MoL_PostStep
-{
-  LANG: C
-  OPTIONS: level
-  SYNC: curv
-  SYNC: lapse
-  SYNC: metric
-  SYNC: shift
-} "apply boundary conditions"
-
-schedule ML_ADM_CheckBoundaries at BASEGRID
-{
-  LANG: C
-  OPTIONS: meta
-} "check boundaries treatment"
-
-schedule group ApplyBCs as ML_ADM_ApplyBCs in MoL_PostStep  after ML_ADM_ApplyBoundConds
-{
-  # no language specified
-  
-} "Apply boundary conditions controlled by thorn Boundary"
diff --git a/m/ML_ADM/src/Boundaries.c b/m/ML_ADM/src/Boundaries.c
deleted file mode 100644
index a79a204..0000000
--- a/m/ML_ADM/src/Boundaries.c
+++ /dev/null
@@ -1,1044 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "cctk_Faces.h"
-#include "util_Table.h"
-#include "Symmetry.h"
-
-
-/* the boundary treatment is split into 3 steps:    */
-/* 1. excision                                      */
-/* 2. symmetries                                    */
-/* 3. "other" boundary conditions, e.g. radiative */
-
-/* to simplify scheduling and testing, the 3 steps  */
-/* are currently applied in separate functions      */
-
-
-void ML_ADM_CheckBoundaries(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  return;
-}
-
-void ML_ADM_ApplyBoundConds(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  CCTK_INT ierr = 0;
-  
-  if (CCTK_EQUALS(curv_bound, "none"  ) ||
-      CCTK_EQUALS(curv_bound, "static") ||
-      CCTK_EQUALS(curv_bound, "flat"  ) ||
-      CCTK_EQUALS(curv_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::curv", curv_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register curv_bound BC for ML_ADM::curv!");
-  }
-  
-  if (CCTK_EQUALS(lapse_bound, "none"  ) ||
-      CCTK_EQUALS(lapse_bound, "static") ||
-      CCTK_EQUALS(lapse_bound, "flat"  ) ||
-      CCTK_EQUALS(lapse_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::lapse", lapse_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register lapse_bound BC for ML_ADM::lapse!");
-  }
-  
-  if (CCTK_EQUALS(metric_bound, "none"  ) ||
-      CCTK_EQUALS(metric_bound, "static") ||
-      CCTK_EQUALS(metric_bound, "flat"  ) ||
-      CCTK_EQUALS(metric_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::metric", metric_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register metric_bound BC for ML_ADM::metric!");
-  }
-  
-  if (CCTK_EQUALS(shift_bound, "none"  ) ||
-      CCTK_EQUALS(shift_bound, "static") ||
-      CCTK_EQUALS(shift_bound, "flat"  ) ||
-      CCTK_EQUALS(shift_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::shift", shift_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register shift_bound BC for ML_ADM::shift!");
-  }
-  
-  if (CCTK_EQUALS(K11_bound, "none"  ) ||
-      CCTK_EQUALS(K11_bound, "static") ||
-      CCTK_EQUALS(K11_bound, "flat"  ) ||
-      CCTK_EQUALS(K11_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::K11", K11_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K11_bound BC for ML_ADM::K11!");
-  }
-  
-  if (CCTK_EQUALS(K21_bound, "none"  ) ||
-      CCTK_EQUALS(K21_bound, "static") ||
-      CCTK_EQUALS(K21_bound, "flat"  ) ||
-      CCTK_EQUALS(K21_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::K21", K21_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K21_bound BC for ML_ADM::K21!");
-  }
-  
-  if (CCTK_EQUALS(K31_bound, "none"  ) ||
-      CCTK_EQUALS(K31_bound, "static") ||
-      CCTK_EQUALS(K31_bound, "flat"  ) ||
-      CCTK_EQUALS(K31_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::K31", K31_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K31_bound BC for ML_ADM::K31!");
-  }
-  
-  if (CCTK_EQUALS(K22_bound, "none"  ) ||
-      CCTK_EQUALS(K22_bound, "static") ||
-      CCTK_EQUALS(K22_bound, "flat"  ) ||
-      CCTK_EQUALS(K22_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::K22", K22_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K22_bound BC for ML_ADM::K22!");
-  }
-  
-  if (CCTK_EQUALS(K32_bound, "none"  ) ||
-      CCTK_EQUALS(K32_bound, "static") ||
-      CCTK_EQUALS(K32_bound, "flat"  ) ||
-      CCTK_EQUALS(K32_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::K32", K32_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K32_bound BC for ML_ADM::K32!");
-  }
-  
-  if (CCTK_EQUALS(K33_bound, "none"  ) ||
-      CCTK_EQUALS(K33_bound, "static") ||
-      CCTK_EQUALS(K33_bound, "flat"  ) ||
-      CCTK_EQUALS(K33_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::K33", K33_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register K33_bound BC for ML_ADM::K33!");
-  }
-  
-  if (CCTK_EQUALS(alpha_bound, "none"  ) ||
-      CCTK_EQUALS(alpha_bound, "static") ||
-      CCTK_EQUALS(alpha_bound, "flat"  ) ||
-      CCTK_EQUALS(alpha_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::alpha", alpha_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register alpha_bound BC for ML_ADM::alpha!");
-  }
-  
-  if (CCTK_EQUALS(g11_bound, "none"  ) ||
-      CCTK_EQUALS(g11_bound, "static") ||
-      CCTK_EQUALS(g11_bound, "flat"  ) ||
-      CCTK_EQUALS(g11_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::g11", g11_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g11_bound BC for ML_ADM::g11!");
-  }
-  
-  if (CCTK_EQUALS(g21_bound, "none"  ) ||
-      CCTK_EQUALS(g21_bound, "static") ||
-      CCTK_EQUALS(g21_bound, "flat"  ) ||
-      CCTK_EQUALS(g21_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::g21", g21_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g21_bound BC for ML_ADM::g21!");
-  }
-  
-  if (CCTK_EQUALS(g31_bound, "none"  ) ||
-      CCTK_EQUALS(g31_bound, "static") ||
-      CCTK_EQUALS(g31_bound, "flat"  ) ||
-      CCTK_EQUALS(g31_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::g31", g31_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g31_bound BC for ML_ADM::g31!");
-  }
-  
-  if (CCTK_EQUALS(g22_bound, "none"  ) ||
-      CCTK_EQUALS(g22_bound, "static") ||
-      CCTK_EQUALS(g22_bound, "flat"  ) ||
-      CCTK_EQUALS(g22_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::g22", g22_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g22_bound BC for ML_ADM::g22!");
-  }
-  
-  if (CCTK_EQUALS(g32_bound, "none"  ) ||
-      CCTK_EQUALS(g32_bound, "static") ||
-      CCTK_EQUALS(g32_bound, "flat"  ) ||
-      CCTK_EQUALS(g32_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::g32", g32_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g32_bound BC for ML_ADM::g32!");
-  }
-  
-  if (CCTK_EQUALS(g33_bound, "none"  ) ||
-      CCTK_EQUALS(g33_bound, "static") ||
-      CCTK_EQUALS(g33_bound, "flat"  ) ||
-      CCTK_EQUALS(g33_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::g33", g33_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register g33_bound BC for ML_ADM::g33!");
-  }
-  
-  if (CCTK_EQUALS(beta1_bound, "none"  ) ||
-      CCTK_EQUALS(beta1_bound, "static") ||
-      CCTK_EQUALS(beta1_bound, "flat"  ) ||
-      CCTK_EQUALS(beta1_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::beta1", beta1_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register beta1_bound BC for ML_ADM::beta1!");
-  }
-  
-  if (CCTK_EQUALS(beta2_bound, "none"  ) ||
-      CCTK_EQUALS(beta2_bound, "static") ||
-      CCTK_EQUALS(beta2_bound, "flat"  ) ||
-      CCTK_EQUALS(beta2_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::beta2", beta2_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register beta2_bound BC for ML_ADM::beta2!");
-  }
-  
-  if (CCTK_EQUALS(beta3_bound, "none"  ) ||
-      CCTK_EQUALS(beta3_bound, "static") ||
-      CCTK_EQUALS(beta3_bound, "flat"  ) ||
-      CCTK_EQUALS(beta3_bound, "zero"  ) ) 
-  {
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1, 
-                      "ML_ADM::beta3", beta3_bound);
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register beta3_bound BC for ML_ADM::beta3!");
-  }
-  
-  if (CCTK_EQUALS(curv_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_curv_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_curv_bound , curv_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_curv_bound ,curv_bound_speed, "SPEED") < 0)
-       CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_curv_bound, 
-                      "ML_ADM::curv", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::curv!");
-  
-  }
-  
-  if (CCTK_EQUALS(lapse_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_lapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_lapse_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_lapse_bound , lapse_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_lapse_bound ,lapse_bound_speed, "SPEED") < 0)
-       CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_lapse_bound, 
-                      "ML_ADM::lapse", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::lapse!");
-  
-  }
-  
-  if (CCTK_EQUALS(metric_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_metric_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_metric_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_metric_bound , metric_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_metric_bound ,metric_bound_speed, "SPEED") < 0)
-       CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_metric_bound, 
-                      "ML_ADM::metric", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::metric!");
-  
-  }
-  
-  if (CCTK_EQUALS(shift_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_shift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_shift_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_shift_bound , shift_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_shift_bound ,shift_bound_speed, "SPEED") < 0)
-       CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_shift_bound, 
-                      "ML_ADM::shift", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::shift!");
-  
-  }
-  
-  if (CCTK_EQUALS(K11_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_K11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K11_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K11_bound , K11_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_K11_bound ,K11_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K11_bound, 
-                      "ML_ADM::K11", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K11!");
-  
-  }
-  
-  if (CCTK_EQUALS(K21_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_K21_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K21_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K21_bound , K21_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_K21_bound ,K21_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K21_bound, 
-                      "ML_ADM::K21", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K21!");
-  
-  }
-  
-  if (CCTK_EQUALS(K31_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_K31_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K31_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K31_bound , K31_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_K31_bound ,K31_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K31_bound, 
-                      "ML_ADM::K31", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K31!");
-  
-  }
-  
-  if (CCTK_EQUALS(K22_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_K22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K22_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K22_bound , K22_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_K22_bound ,K22_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K22_bound, 
-                      "ML_ADM::K22", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K22!");
-  
-  }
-  
-  if (CCTK_EQUALS(K32_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_K32_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K32_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K32_bound , K32_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_K32_bound ,K32_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K32_bound, 
-                      "ML_ADM::K32", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K32!");
-  
-  }
-  
-  if (CCTK_EQUALS(K33_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_K33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K33_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K33_bound , K33_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_K33_bound ,K33_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K33_bound, 
-                      "ML_ADM::K33", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::K33!");
-  
-  }
-  
-  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!");
-    if (Util_TableSetReal(handle_alpha_bound , alpha_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "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!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_alpha_bound, 
-                      "ML_ADM::alpha", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::alpha!");
-  
-  }
-  
-  if (CCTK_EQUALS(g11_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_g11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g11_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g11_bound , g11_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g11_bound ,g11_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g11_bound, 
-                      "ML_ADM::g11", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::g11!");
-  
-  }
-  
-  if (CCTK_EQUALS(g21_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_g21_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g21_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g21_bound , g21_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g21_bound ,g21_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g21_bound, 
-                      "ML_ADM::g21", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::g21!");
-  
-  }
-  
-  if (CCTK_EQUALS(g31_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_g31_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g31_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g31_bound , g31_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g31_bound ,g31_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g31_bound, 
-                      "ML_ADM::g31", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::g31!");
-  
-  }
-  
-  if (CCTK_EQUALS(g22_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_g22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g22_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g22_bound , g22_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g22_bound ,g22_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g22_bound, 
-                      "ML_ADM::g22", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::g22!");
-  
-  }
-  
-  if (CCTK_EQUALS(g32_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_g32_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g32_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g32_bound , g32_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g32_bound ,g32_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g32_bound, 
-                      "ML_ADM::g32", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::g32!");
-  
-  }
-  
-  if (CCTK_EQUALS(g33_bound, "radiative"))
-  {
-   /* apply radiation boundary condition */
-    CCTK_INT handle_g33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g33_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g33_bound , g33_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "could not set LIMIT value in table!");
-    if (Util_TableSetReal(handle_g33_bound ,g33_bound_speed, "SPEED") < 0)
-        CCTK_WARN(-1, "could not set SPEED value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g33_bound, 
-                      "ML_ADM::g33", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::g33!");
-  
-  }
-  
-  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!");
-    if (Util_TableSetReal(handle_beta1_bound , beta1_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "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!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta1_bound, 
-                      "ML_ADM::beta1", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::beta1!");
-  
-  }
-  
-  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!");
-    if (Util_TableSetReal(handle_beta2_bound , beta2_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "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!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta2_bound, 
-                      "ML_ADM::beta2", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::beta2!");
-  
-  }
-  
-  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!");
-    if (Util_TableSetReal(handle_beta3_bound , beta3_bound_limit, "LIMIT") < 0)
-       CCTK_WARN(-1, "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!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta3_bound, 
-                      "ML_ADM::beta3", "Radiation");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Radiation BC for ML_ADM::beta3!");
-  
-  }
-  
-  if (CCTK_EQUALS(curv_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_curv_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_curv_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_curv_bound ,curv_bound_scalar, "SCALAR") < 0)
-        CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_curv_bound, 
-                      "ML_ADM::curv", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_ADM::curv!");
-  
-  }
-  
-  if (CCTK_EQUALS(lapse_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_lapse_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_lapse_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_lapse_bound ,lapse_bound_scalar, "SCALAR") < 0)
-        CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_lapse_bound, 
-                      "ML_ADM::lapse", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_ADM::lapse!");
-  
-  }
-  
-  if (CCTK_EQUALS(metric_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_metric_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_metric_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_metric_bound ,metric_bound_scalar, "SCALAR") < 0)
-        CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_metric_bound, 
-                      "ML_ADM::metric", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_ADM::metric!");
-  
-  }
-  
-  if (CCTK_EQUALS(shift_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_shift_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_shift_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_shift_bound ,shift_bound_scalar, "SCALAR") < 0)
-        CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_shift_bound, 
-                      "ML_ADM::shift", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Failed to register Scalar BC for ML_ADM::shift!");
-  
-  }
-  
-  if (CCTK_EQUALS(K11_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_K11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K11_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K11_bound ,K11_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K11_bound, 
-                      "ML_ADM::K11", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K11!");
-  
-  }
-  
-  if (CCTK_EQUALS(K21_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_K21_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K21_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K21_bound ,K21_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K21_bound, 
-                      "ML_ADM::K21", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K21!");
-  
-  }
-  
-  if (CCTK_EQUALS(K31_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_K31_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K31_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K31_bound ,K31_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K31_bound, 
-                      "ML_ADM::K31", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K31!");
-  
-  }
-  
-  if (CCTK_EQUALS(K22_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_K22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K22_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K22_bound ,K22_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K22_bound, 
-                      "ML_ADM::K22", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K22!");
-  
-  }
-  
-  if (CCTK_EQUALS(K32_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_K32_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K32_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K32_bound ,K32_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K32_bound, 
-                      "ML_ADM::K32", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K32!");
-  
-  }
-  
-  if (CCTK_EQUALS(K33_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_K33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_K33_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_K33_bound ,K33_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_K33_bound, 
-                      "ML_ADM::K33", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::K33!");
-  
-  }
-  
-  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!");
-    if (Util_TableSetReal(handle_alpha_bound ,alpha_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_alpha_bound, 
-                      "ML_ADM::alpha", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::alpha!");
-  
-  }
-  
-  if (CCTK_EQUALS(g11_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_g11_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g11_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g11_bound ,g11_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g11_bound, 
-                      "ML_ADM::g11", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::g11!");
-  
-  }
-  
-  if (CCTK_EQUALS(g21_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_g21_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g21_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g21_bound ,g21_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g21_bound, 
-                      "ML_ADM::g21", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::g21!");
-  
-  }
-  
-  if (CCTK_EQUALS(g31_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_g31_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g31_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g31_bound ,g31_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g31_bound, 
-                      "ML_ADM::g31", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::g31!");
-  
-  }
-  
-  if (CCTK_EQUALS(g22_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_g22_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g22_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g22_bound ,g22_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g22_bound, 
-                      "ML_ADM::g22", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::g22!");
-  
-  }
-  
-  if (CCTK_EQUALS(g32_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_g32_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g32_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g32_bound ,g32_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g32_bound, 
-                      "ML_ADM::g32", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::g32!");
-  
-  }
-  
-  if (CCTK_EQUALS(g33_bound, "scalar"))
-  {
-   /* apply scalar boundary condition */
-    CCTK_INT handle_g33_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
-    if (handle_g33_bound < 0) CCTK_WARN(-1, "could not create table!");
-    if (Util_TableSetReal(handle_g33_bound ,g33_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_g33_bound, 
-                      "ML_ADM::g33", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::g33!");
-  
-  }
-  
-  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!");
-    if (Util_TableSetReal(handle_beta1_bound ,beta1_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta1_bound, 
-                      "ML_ADM::beta1", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::beta1!");
-  
-  }
-  
-  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!");
-    if (Util_TableSetReal(handle_beta2_bound ,beta2_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta2_bound, 
-                      "ML_ADM::beta2", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::beta2!");
-  
-  }
-  
-  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!");
-    if (Util_TableSetReal(handle_beta3_bound ,beta3_bound_scalar, "SCALAR") < 0)
-      CCTK_WARN(-1, "could not set SCALAR value in table!");
-  
-    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_beta3_bound, 
-                      "ML_ADM::beta3", "scalar");
-  
-    if (ierr < 0)
-       CCTK_WARN(-1, "Error in registering Scalar BC for ML_ADM::beta3!");
-  
-  }
-  return;
-}
-
-
-
-/* template for entries in parameter file:
-#$bound$#ML_ADM::curv_bound       = "skip"
-#$bound$#ML_ADM::curv_bound_speed = 1.0
-#$bound$#ML_ADM::curv_bound_limit = 0.0
-#$bound$#ML_ADM::curv_bound_scalar = 0.0
-
-#$bound$#ML_ADM::lapse_bound       = "skip"
-#$bound$#ML_ADM::lapse_bound_speed = 1.0
-#$bound$#ML_ADM::lapse_bound_limit = 0.0
-#$bound$#ML_ADM::lapse_bound_scalar = 0.0
-
-#$bound$#ML_ADM::metric_bound       = "skip"
-#$bound$#ML_ADM::metric_bound_speed = 1.0
-#$bound$#ML_ADM::metric_bound_limit = 0.0
-#$bound$#ML_ADM::metric_bound_scalar = 0.0
-
-#$bound$#ML_ADM::shift_bound       = "skip"
-#$bound$#ML_ADM::shift_bound_speed = 1.0
-#$bound$#ML_ADM::shift_bound_limit = 0.0
-#$bound$#ML_ADM::shift_bound_scalar = 0.0
-
-#$bound$#ML_ADM::K11_bound       = "skip"
-#$bound$#ML_ADM::K11_bound_speed = 1.0
-#$bound$#ML_ADM::K11_bound_limit = 0.0
-#$bound$#ML_ADM::K11_bound_scalar = 0.0
-
-#$bound$#ML_ADM::K21_bound       = "skip"
-#$bound$#ML_ADM::K21_bound_speed = 1.0
-#$bound$#ML_ADM::K21_bound_limit = 0.0
-#$bound$#ML_ADM::K21_bound_scalar = 0.0
-
-#$bound$#ML_ADM::K31_bound       = "skip"
-#$bound$#ML_ADM::K31_bound_speed = 1.0
-#$bound$#ML_ADM::K31_bound_limit = 0.0
-#$bound$#ML_ADM::K31_bound_scalar = 0.0
-
-#$bound$#ML_ADM::K22_bound       = "skip"
-#$bound$#ML_ADM::K22_bound_speed = 1.0
-#$bound$#ML_ADM::K22_bound_limit = 0.0
-#$bound$#ML_ADM::K22_bound_scalar = 0.0
-
-#$bound$#ML_ADM::K32_bound       = "skip"
-#$bound$#ML_ADM::K32_bound_speed = 1.0
-#$bound$#ML_ADM::K32_bound_limit = 0.0
-#$bound$#ML_ADM::K32_bound_scalar = 0.0
-
-#$bound$#ML_ADM::K33_bound       = "skip"
-#$bound$#ML_ADM::K33_bound_speed = 1.0
-#$bound$#ML_ADM::K33_bound_limit = 0.0
-#$bound$#ML_ADM::K33_bound_scalar = 0.0
-
-#$bound$#ML_ADM::alpha_bound       = "skip"
-#$bound$#ML_ADM::alpha_bound_speed = 1.0
-#$bound$#ML_ADM::alpha_bound_limit = 0.0
-#$bound$#ML_ADM::alpha_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g11_bound       = "skip"
-#$bound$#ML_ADM::g11_bound_speed = 1.0
-#$bound$#ML_ADM::g11_bound_limit = 0.0
-#$bound$#ML_ADM::g11_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g21_bound       = "skip"
-#$bound$#ML_ADM::g21_bound_speed = 1.0
-#$bound$#ML_ADM::g21_bound_limit = 0.0
-#$bound$#ML_ADM::g21_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g31_bound       = "skip"
-#$bound$#ML_ADM::g31_bound_speed = 1.0
-#$bound$#ML_ADM::g31_bound_limit = 0.0
-#$bound$#ML_ADM::g31_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g22_bound       = "skip"
-#$bound$#ML_ADM::g22_bound_speed = 1.0
-#$bound$#ML_ADM::g22_bound_limit = 0.0
-#$bound$#ML_ADM::g22_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g32_bound       = "skip"
-#$bound$#ML_ADM::g32_bound_speed = 1.0
-#$bound$#ML_ADM::g32_bound_limit = 0.0
-#$bound$#ML_ADM::g32_bound_scalar = 0.0
-
-#$bound$#ML_ADM::g33_bound       = "skip"
-#$bound$#ML_ADM::g33_bound_speed = 1.0
-#$bound$#ML_ADM::g33_bound_limit = 0.0
-#$bound$#ML_ADM::g33_bound_scalar = 0.0
-
-#$bound$#ML_ADM::beta1_bound       = "skip"
-#$bound$#ML_ADM::beta1_bound_speed = 1.0
-#$bound$#ML_ADM::beta1_bound_limit = 0.0
-#$bound$#ML_ADM::beta1_bound_scalar = 0.0
-
-#$bound$#ML_ADM::beta2_bound       = "skip"
-#$bound$#ML_ADM::beta2_bound_speed = 1.0
-#$bound$#ML_ADM::beta2_bound_limit = 0.0
-#$bound$#ML_ADM::beta2_bound_scalar = 0.0
-
-#$bound$#ML_ADM::beta3_bound       = "skip"
-#$bound$#ML_ADM::beta3_bound_speed = 1.0
-#$bound$#ML_ADM::beta3_bound_limit = 0.0
-#$bound$#ML_ADM::beta3_bound_scalar = 0.0
-
-*/
-
diff --git a/m/ML_ADM/src/Differencing.h b/m/ML_ADM/src/Differencing.h
deleted file mode 100644
index 7ada6a7..0000000
--- a/m/ML_ADM/src/Differencing.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#define PDstandard4th1(u,i,j,k) (p1o12dx*(-8*u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,k)] + 8*u[CCTK_GFINDEX3D(cctkGH,1 + i,j,k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,k)] - u[CCTK_GFINDEX3D(cctkGH,2 + i,j,k)]))
-#define PDstandard4th2(u,i,j,k) (p1o12dy*(-8*u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,k)] + 8*u[CCTK_GFINDEX3D(cctkGH,i,1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,k)] - u[CCTK_GFINDEX3D(cctkGH,i,2 + j,k)]))
-#define PDstandard4th3(u,i,j,k) (p1o12dz*(-8*u[CCTK_GFINDEX3D(cctkGH,i,j,-1 + k)] + 8*u[CCTK_GFINDEX3D(cctkGH,i,j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,j,-2 + k)] - u[CCTK_GFINDEX3D(cctkGH,i,j,2 + k)]))
-#define PDstandard4th11(u,i,j,k) (pm1o12dx2*(-16*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,k)]) + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,k)] + 30*u[CCTK_GFINDEX3D(cctkGH,i,j,k)]))
-#define PDstandard4th22(u,i,j,k) (pm1o12dy2*(-16*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,k)]) + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,k)] + 30*u[CCTK_GFINDEX3D(cctkGH,i,j,k)]))
-#define PDstandard4th33(u,i,j,k) (pm1o12dz2*(-16*(u[CCTK_GFINDEX3D(cctkGH,i,j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,j,1 + k)]) + u[CCTK_GFINDEX3D(cctkGH,i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,j,2 + k)] + 30*u[CCTK_GFINDEX3D(cctkGH,i,j,k)]))
-#define PDstandard4th12(u,i,j,k) (p1o144dxdy*(-64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,-1 + j,k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,-1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,1 + j,k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,-1 + j,k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,-1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,1 + j,k)]) + u[CCTK_GFINDEX3D(cctkGH,-2 + i,-2 + j,k)] - u[CCTK_GFINDEX3D(cctkGH,-2 + i,2 + j,k)] - u[CCTK_GFINDEX3D(cctkGH,2 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,2 + j,k)]))
-#define PDstandard4th13(u,i,j,k) (p1o144dxdz*(-64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,-1 + k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,1 + k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,-1 + k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,1 + k)]) + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,-2 + k)] - u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,2 + k)] - u[CCTK_GFINDEX3D(cctkGH,2 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,2 + k)]))
-#define PDstandard4th21(u,i,j,k) (p1o144dxdy*(-64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,-1 + j,k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,-1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,1 + j,k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,-1 + j,k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,-1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,1 + j,k)]) + u[CCTK_GFINDEX3D(cctkGH,-2 + i,-2 + j,k)] - u[CCTK_GFINDEX3D(cctkGH,-2 + i,2 + j,k)] - u[CCTK_GFINDEX3D(cctkGH,2 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,2 + j,k)]))
-#define PDstandard4th23(u,i,j,k) (p1o144dydz*(-64*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,-1 + k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,1 + k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,-1 + k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,1 + k)]) + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,-2 + k)] - u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,2 + k)] - u[CCTK_GFINDEX3D(cctkGH,i,2 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,2 + k)]))
-#define PDstandard4th31(u,i,j,k) (p1o144dxdz*(-64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,-1 + k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,1 + k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,-1 + k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,1 + k)]) + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,-2 + k)] - u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,2 + k)] - u[CCTK_GFINDEX3D(cctkGH,2 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,2 + k)]))
-#define PDstandard4th32(u,i,j,k) (p1o144dydz*(-64*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,-1 + k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,1 + k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,-1 + k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,1 + k)]) + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,-2 + k)] - u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,2 + k)] - u[CCTK_GFINDEX3D(cctkGH,i,2 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,2 + k)]))
diff --git a/m/ML_ADM/src/ML_ADM_Minkowski.c b/m/ML_ADM/src/ML_ADM_Minkowski.c
deleted file mode 100644
index 9319aea..0000000
--- a/m/ML_ADM/src/ML_ADM_Minkowski.c
+++ /dev/null
@@ -1,180 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_ADM_Minkowski_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_ADM_Minkowski_Body");
-  }
-  
-  if (cctk_iteration % ML_ADM_Minkowski_calc_every != ML_ADM_Minkowski_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL alphaL = INITVALUE;
-    CCTK_REAL beta1L = INITVALUE, beta2L = INITVALUE, beta3L = INITVALUE;
-    CCTK_REAL g11L = INITVALUE, g21L = INITVALUE, g22L = INITVALUE, g31L = INITVALUE, g32L = INITVALUE, g33L = INITVALUE;
-    CCTK_REAL K11L = INITVALUE, K21L = INITVALUE, K22L = INITVALUE, K31L = INITVALUE, K32L = INITVALUE, K33L = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    
-    /* Assign local copies of grid functions */
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    g11L  =  1;
-    
-    g21L  =  0;
-    
-    g31L  =  0;
-    
-    g22L  =  1;
-    
-    g32L  =  0;
-    
-    g33L  =  1;
-    
-    K11L  =  0;
-    
-    K21L  =  0;
-    
-    K31L  =  0;
-    
-    K22L  =  0;
-    
-    K32L  =  0;
-    
-    K33L  =  0;
-    
-    alphaL  =  1;
-    
-    beta1L  =  0;
-    
-    beta2L  =  0;
-    
-    beta3L  =  0;
-    
-    
-    /* Copy local copies back to grid functions */
-    alpha[index] = alphaL;
-    beta1[index] = beta1L;
-    beta2[index] = beta2L;
-    beta3[index] = beta3L;
-    g11[index] = g11L;
-    g21[index] = g21L;
-    g22[index] = g22L;
-    g31[index] = g31L;
-    g32[index] = g32L;
-    g33[index] = g33L;
-    K11[index] = K11L;
-    K21[index] = K21L;
-    K22[index] = K22L;
-    K31[index] = K31L;
-    K32[index] = K32L;
-    K33[index] = K33L;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_ADM_Minkowski(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverEverything(cctkGH, &ML_ADM_Minkowski_Body);
-}
diff --git a/m/ML_ADM/src/ML_ADM_RHS.c b/m/ML_ADM/src/ML_ADM_RHS.c
deleted file mode 100644
index 2b1d7d4..0000000
--- a/m/ML_ADM/src/ML_ADM_RHS.c
+++ /dev/null
@@ -1,536 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_ADM_RHS_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_ADM_RHS_Body");
-  }
-  
-  if (cctk_iteration % ML_ADM_RHS_calc_every != ML_ADM_RHS_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    CCTK_REAL detg = INITVALUE;
-    CCTK_REAL G111 = INITVALUE, G121 = INITVALUE, G122 = INITVALUE, G131 = INITVALUE, G132 = INITVALUE, G133 = INITVALUE;
-    CCTK_REAL G211 = INITVALUE, G221 = INITVALUE, G222 = INITVALUE, G231 = INITVALUE, G232 = INITVALUE, G233 = INITVALUE;
-    CCTK_REAL G311 = INITVALUE, G321 = INITVALUE, G322 = INITVALUE, G331 = INITVALUE, G332 = INITVALUE, G333 = INITVALUE;
-    CCTK_REAL gu11 = INITVALUE, gu12 = INITVALUE, gu13 = INITVALUE, gu22 = INITVALUE, gu23 = INITVALUE, gu33 = INITVALUE;
-    CCTK_REAL Km11 = INITVALUE, Km12 = INITVALUE, Km13 = INITVALUE, Km21 = INITVALUE, Km22 = INITVALUE, Km23 = INITVALUE;
-    CCTK_REAL Km31 = INITVALUE, Km32 = INITVALUE, Km33 = INITVALUE;
-    CCTK_REAL R11 = INITVALUE, R21 = INITVALUE, R22 = INITVALUE, R31 = INITVALUE, R32 = INITVALUE, R33 = INITVALUE;
-    CCTK_REAL trK = INITVALUE;
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL alphaL = INITVALUE, alpharhsL = INITVALUE;
-    CCTK_REAL beta1L = INITVALUE, beta1rhsL = INITVALUE, beta2L = INITVALUE, beta2rhsL = INITVALUE, beta3L = INITVALUE, beta3rhsL = INITVALUE;
-    CCTK_REAL g11L = INITVALUE, g11rhsL = INITVALUE, g21L = INITVALUE, g21rhsL = INITVALUE, g22L = INITVALUE, g22rhsL = INITVALUE;
-    CCTK_REAL g31L = INITVALUE, g31rhsL = INITVALUE, g32L = INITVALUE, g32rhsL = INITVALUE, g33L = INITVALUE, g33rhsL = INITVALUE;
-    CCTK_REAL K11L = INITVALUE, K11rhsL = INITVALUE, K21L = INITVALUE, K21rhsL = INITVALUE, K22L = INITVALUE, K22rhsL = INITVALUE;
-    CCTK_REAL K31L = INITVALUE, K31rhsL = INITVALUE, K32L = INITVALUE, K32rhsL = INITVALUE, K33L = INITVALUE, K33rhsL = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    CCTK_REAL PDstandard4th1alpha = INITVALUE;
-    CCTK_REAL PDstandard4th2alpha = INITVALUE;
-    CCTK_REAL PDstandard4th3alpha = INITVALUE;
-    CCTK_REAL PDstandard4th11alpha = INITVALUE;
-    CCTK_REAL PDstandard4th22alpha = INITVALUE;
-    CCTK_REAL PDstandard4th33alpha = INITVALUE;
-    CCTK_REAL PDstandard4th12alpha = INITVALUE;
-    CCTK_REAL PDstandard4th13alpha = INITVALUE;
-    CCTK_REAL PDstandard4th23alpha = INITVALUE;
-    CCTK_REAL PDstandard4th1beta1 = INITVALUE;
-    CCTK_REAL PDstandard4th2beta1 = INITVALUE;
-    CCTK_REAL PDstandard4th3beta1 = INITVALUE;
-    CCTK_REAL PDstandard4th1beta2 = INITVALUE;
-    CCTK_REAL PDstandard4th2beta2 = INITVALUE;
-    CCTK_REAL PDstandard4th3beta2 = INITVALUE;
-    CCTK_REAL PDstandard4th1beta3 = INITVALUE;
-    CCTK_REAL PDstandard4th2beta3 = INITVALUE;
-    CCTK_REAL PDstandard4th3beta3 = INITVALUE;
-    CCTK_REAL PDstandard4th1g11 = INITVALUE;
-    CCTK_REAL PDstandard4th2g11 = INITVALUE;
-    CCTK_REAL PDstandard4th3g11 = INITVALUE;
-    CCTK_REAL PDstandard4th22g11 = INITVALUE;
-    CCTK_REAL PDstandard4th33g11 = INITVALUE;
-    CCTK_REAL PDstandard4th12g11 = INITVALUE;
-    CCTK_REAL PDstandard4th13g11 = INITVALUE;
-    CCTK_REAL PDstandard4th21g11 = INITVALUE;
-    CCTK_REAL PDstandard4th23g11 = INITVALUE;
-    CCTK_REAL PDstandard4th31g11 = INITVALUE;
-    CCTK_REAL PDstandard4th32g11 = INITVALUE;
-    CCTK_REAL PDstandard4th1g21 = INITVALUE;
-    CCTK_REAL PDstandard4th2g21 = INITVALUE;
-    CCTK_REAL PDstandard4th3g21 = INITVALUE;
-    CCTK_REAL PDstandard4th33g21 = INITVALUE;
-    CCTK_REAL PDstandard4th12g21 = INITVALUE;
-    CCTK_REAL PDstandard4th13g21 = INITVALUE;
-    CCTK_REAL PDstandard4th21g21 = INITVALUE;
-    CCTK_REAL PDstandard4th23g21 = INITVALUE;
-    CCTK_REAL PDstandard4th31g21 = INITVALUE;
-    CCTK_REAL PDstandard4th32g21 = INITVALUE;
-    CCTK_REAL PDstandard4th1g22 = INITVALUE;
-    CCTK_REAL PDstandard4th2g22 = INITVALUE;
-    CCTK_REAL PDstandard4th3g22 = INITVALUE;
-    CCTK_REAL PDstandard4th11g22 = INITVALUE;
-    CCTK_REAL PDstandard4th33g22 = INITVALUE;
-    CCTK_REAL PDstandard4th12g22 = INITVALUE;
-    CCTK_REAL PDstandard4th13g22 = INITVALUE;
-    CCTK_REAL PDstandard4th21g22 = INITVALUE;
-    CCTK_REAL PDstandard4th23g22 = INITVALUE;
-    CCTK_REAL PDstandard4th31g22 = INITVALUE;
-    CCTK_REAL PDstandard4th32g22 = INITVALUE;
-    CCTK_REAL PDstandard4th1g31 = INITVALUE;
-    CCTK_REAL PDstandard4th2g31 = INITVALUE;
-    CCTK_REAL PDstandard4th3g31 = INITVALUE;
-    CCTK_REAL PDstandard4th22g31 = INITVALUE;
-    CCTK_REAL PDstandard4th12g31 = INITVALUE;
-    CCTK_REAL PDstandard4th13g31 = INITVALUE;
-    CCTK_REAL PDstandard4th21g31 = INITVALUE;
-    CCTK_REAL PDstandard4th23g31 = INITVALUE;
-    CCTK_REAL PDstandard4th31g31 = INITVALUE;
-    CCTK_REAL PDstandard4th32g31 = INITVALUE;
-    CCTK_REAL PDstandard4th1g32 = INITVALUE;
-    CCTK_REAL PDstandard4th2g32 = INITVALUE;
-    CCTK_REAL PDstandard4th3g32 = INITVALUE;
-    CCTK_REAL PDstandard4th11g32 = INITVALUE;
-    CCTK_REAL PDstandard4th12g32 = INITVALUE;
-    CCTK_REAL PDstandard4th13g32 = INITVALUE;
-    CCTK_REAL PDstandard4th21g32 = INITVALUE;
-    CCTK_REAL PDstandard4th23g32 = INITVALUE;
-    CCTK_REAL PDstandard4th31g32 = INITVALUE;
-    CCTK_REAL PDstandard4th32g32 = INITVALUE;
-    CCTK_REAL PDstandard4th1g33 = INITVALUE;
-    CCTK_REAL PDstandard4th2g33 = INITVALUE;
-    CCTK_REAL PDstandard4th3g33 = INITVALUE;
-    CCTK_REAL PDstandard4th11g33 = INITVALUE;
-    CCTK_REAL PDstandard4th22g33 = INITVALUE;
-    CCTK_REAL PDstandard4th12g33 = INITVALUE;
-    CCTK_REAL PDstandard4th13g33 = INITVALUE;
-    CCTK_REAL PDstandard4th21g33 = INITVALUE;
-    CCTK_REAL PDstandard4th23g33 = INITVALUE;
-    CCTK_REAL PDstandard4th31g33 = INITVALUE;
-    CCTK_REAL PDstandard4th32g33 = INITVALUE;
-    CCTK_REAL PDstandard4th1K11 = INITVALUE;
-    CCTK_REAL PDstandard4th2K11 = INITVALUE;
-    CCTK_REAL PDstandard4th3K11 = INITVALUE;
-    CCTK_REAL PDstandard4th1K21 = INITVALUE;
-    CCTK_REAL PDstandard4th2K21 = INITVALUE;
-    CCTK_REAL PDstandard4th3K21 = INITVALUE;
-    CCTK_REAL PDstandard4th1K22 = INITVALUE;
-    CCTK_REAL PDstandard4th2K22 = INITVALUE;
-    CCTK_REAL PDstandard4th3K22 = INITVALUE;
-    CCTK_REAL PDstandard4th1K31 = INITVALUE;
-    CCTK_REAL PDstandard4th2K31 = INITVALUE;
-    CCTK_REAL PDstandard4th3K31 = INITVALUE;
-    CCTK_REAL PDstandard4th1K32 = INITVALUE;
-    CCTK_REAL PDstandard4th2K32 = INITVALUE;
-    CCTK_REAL PDstandard4th3K32 = INITVALUE;
-    CCTK_REAL PDstandard4th1K33 = INITVALUE;
-    CCTK_REAL PDstandard4th2K33 = INITVALUE;
-    CCTK_REAL PDstandard4th3K33 = INITVALUE;
-    
-    /* Assign local copies of grid functions */
-    alphaL = alpha[index];
-    beta1L = beta1[index];
-    beta2L = beta2[index];
-    beta3L = beta3[index];
-    g11L = g11[index];
-    g21L = g21[index];
-    g22L = g22[index];
-    g31L = g31[index];
-    g32L = g32[index];
-    g33L = g33[index];
-    K11L = K11[index];
-    K21L = K21[index];
-    K22L = K22[index];
-    K31L = K31[index];
-    K32L = K32[index];
-    K33L = K33[index];
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    PDstandard4th1alpha = PDstandard4th1(alpha, i, j, k);
-    PDstandard4th2alpha = PDstandard4th2(alpha, i, j, k);
-    PDstandard4th3alpha = PDstandard4th3(alpha, i, j, k);
-    PDstandard4th11alpha = PDstandard4th11(alpha, i, j, k);
-    PDstandard4th22alpha = PDstandard4th22(alpha, i, j, k);
-    PDstandard4th33alpha = PDstandard4th33(alpha, i, j, k);
-    PDstandard4th12alpha = PDstandard4th12(alpha, i, j, k);
-    PDstandard4th13alpha = PDstandard4th13(alpha, i, j, k);
-    PDstandard4th23alpha = PDstandard4th23(alpha, i, j, k);
-    PDstandard4th1beta1 = PDstandard4th1(beta1, i, j, k);
-    PDstandard4th2beta1 = PDstandard4th2(beta1, i, j, k);
-    PDstandard4th3beta1 = PDstandard4th3(beta1, i, j, k);
-    PDstandard4th1beta2 = PDstandard4th1(beta2, i, j, k);
-    PDstandard4th2beta2 = PDstandard4th2(beta2, i, j, k);
-    PDstandard4th3beta2 = PDstandard4th3(beta2, i, j, k);
-    PDstandard4th1beta3 = PDstandard4th1(beta3, i, j, k);
-    PDstandard4th2beta3 = PDstandard4th2(beta3, i, j, k);
-    PDstandard4th3beta3 = PDstandard4th3(beta3, i, j, k);
-    PDstandard4th1g11 = PDstandard4th1(g11, i, j, k);
-    PDstandard4th2g11 = PDstandard4th2(g11, i, j, k);
-    PDstandard4th3g11 = PDstandard4th3(g11, i, j, k);
-    PDstandard4th22g11 = PDstandard4th22(g11, i, j, k);
-    PDstandard4th33g11 = PDstandard4th33(g11, i, j, k);
-    PDstandard4th23g11 = PDstandard4th23(g11, i, j, k);
-    PDstandard4th1g21 = PDstandard4th1(g21, i, j, k);
-    PDstandard4th2g21 = PDstandard4th2(g21, i, j, k);
-    PDstandard4th3g21 = PDstandard4th3(g21, i, j, k);
-    PDstandard4th33g21 = PDstandard4th33(g21, i, j, k);
-    PDstandard4th12g21 = PDstandard4th12(g21, i, j, k);
-    PDstandard4th13g21 = PDstandard4th13(g21, i, j, k);
-    PDstandard4th23g21 = PDstandard4th23(g21, i, j, k);
-    PDstandard4th1g22 = PDstandard4th1(g22, i, j, k);
-    PDstandard4th2g22 = PDstandard4th2(g22, i, j, k);
-    PDstandard4th3g22 = PDstandard4th3(g22, i, j, k);
-    PDstandard4th11g22 = PDstandard4th11(g22, i, j, k);
-    PDstandard4th33g22 = PDstandard4th33(g22, i, j, k);
-    PDstandard4th13g22 = PDstandard4th13(g22, i, j, k);
-    PDstandard4th1g31 = PDstandard4th1(g31, i, j, k);
-    PDstandard4th2g31 = PDstandard4th2(g31, i, j, k);
-    PDstandard4th3g31 = PDstandard4th3(g31, i, j, k);
-    PDstandard4th22g31 = PDstandard4th22(g31, i, j, k);
-    PDstandard4th12g31 = PDstandard4th12(g31, i, j, k);
-    PDstandard4th13g31 = PDstandard4th13(g31, i, j, k);
-    PDstandard4th23g31 = PDstandard4th23(g31, i, j, k);
-    PDstandard4th1g32 = PDstandard4th1(g32, i, j, k);
-    PDstandard4th2g32 = PDstandard4th2(g32, i, j, k);
-    PDstandard4th3g32 = PDstandard4th3(g32, i, j, k);
-    PDstandard4th11g32 = PDstandard4th11(g32, i, j, k);
-    PDstandard4th12g32 = PDstandard4th12(g32, i, j, k);
-    PDstandard4th13g32 = PDstandard4th13(g32, i, j, k);
-    PDstandard4th23g32 = PDstandard4th23(g32, i, j, k);
-    PDstandard4th1g33 = PDstandard4th1(g33, i, j, k);
-    PDstandard4th2g33 = PDstandard4th2(g33, i, j, k);
-    PDstandard4th3g33 = PDstandard4th3(g33, i, j, k);
-    PDstandard4th11g33 = PDstandard4th11(g33, i, j, k);
-    PDstandard4th22g33 = PDstandard4th22(g33, i, j, k);
-    PDstandard4th12g33 = PDstandard4th12(g33, i, j, k);
-    PDstandard4th1K11 = PDstandard4th1(K11, i, j, k);
-    PDstandard4th2K11 = PDstandard4th2(K11, i, j, k);
-    PDstandard4th3K11 = PDstandard4th3(K11, i, j, k);
-    PDstandard4th1K21 = PDstandard4th1(K21, i, j, k);
-    PDstandard4th2K21 = PDstandard4th2(K21, i, j, k);
-    PDstandard4th3K21 = PDstandard4th3(K21, i, j, k);
-    PDstandard4th1K22 = PDstandard4th1(K22, i, j, k);
-    PDstandard4th2K22 = PDstandard4th2(K22, i, j, k);
-    PDstandard4th3K22 = PDstandard4th3(K22, i, j, k);
-    PDstandard4th1K31 = PDstandard4th1(K31, i, j, k);
-    PDstandard4th2K31 = PDstandard4th2(K31, i, j, k);
-    PDstandard4th3K31 = PDstandard4th3(K31, i, j, k);
-    PDstandard4th1K32 = PDstandard4th1(K32, i, j, k);
-    PDstandard4th2K32 = PDstandard4th2(K32, i, j, k);
-    PDstandard4th3K32 = PDstandard4th3(K32, i, j, k);
-    PDstandard4th1K33 = PDstandard4th1(K33, i, j, k);
-    PDstandard4th2K33 = PDstandard4th2(K33, i, j, k);
-    PDstandard4th3K33 = PDstandard4th3(K33, i, j, k);
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    detg  =  2*g21L*g31L*g32L + g33L*(g11L*g22L - SQR(g21L)) - g22L*SQR(g31L) - g11L*SQR(g32L);
-    
-    gu11  =  INV(detg)*(g22L*g33L - SQR(g32L));
-    
-    gu12  =  (g31L*g32L - g21L*g33L)*INV(detg);
-    
-    gu13  =  (-(g22L*g31L) + g21L*g32L)*INV(detg);
-    
-    gu22  =  INV(detg)*(g11L*g33L - SQR(g31L));
-    
-    gu23  =  (g21L*g31L - g11L*g32L)*INV(detg);
-    
-    gu33  =  INV(detg)*(g11L*g22L - SQR(g21L));
-    
-    G111  =  khalf*(gu11*PDstandard4th1g11 + 2*(gu12*PDstandard4th1g21 + gu13*PDstandard4th1g31) - gu12*PDstandard4th2g11 - 
-          gu13*PDstandard4th3g11);
-    
-    G211  =  khalf*(gu12*PDstandard4th1g11 + 2*(gu22*PDstandard4th1g21 + gu23*PDstandard4th1g31) - gu22*PDstandard4th2g11 - 
-          gu23*PDstandard4th3g11);
-    
-    G311  =  khalf*(gu13*PDstandard4th1g11 + 2*(gu23*PDstandard4th1g21 + gu33*PDstandard4th1g31) - gu23*PDstandard4th2g11 - 
-          gu33*PDstandard4th3g11);
-    
-    G121  =  khalf*(gu12*PDstandard4th1g22 + gu11*PDstandard4th2g11 + 
-          gu13*(PDstandard4th1g32 + PDstandard4th2g31 - PDstandard4th3g21));
-    
-    G221  =  khalf*(gu22*PDstandard4th1g22 + gu12*PDstandard4th2g11 + 
-          gu23*(PDstandard4th1g32 + PDstandard4th2g31 - PDstandard4th3g21));
-    
-    G321  =  khalf*(gu23*PDstandard4th1g22 + gu13*PDstandard4th2g11 + 
-          gu33*(PDstandard4th1g32 + PDstandard4th2g31 - PDstandard4th3g21));
-    
-    G131  =  khalf*(gu13*PDstandard4th1g33 + gu11*PDstandard4th3g11 + 
-          gu12*(PDstandard4th1g32 - PDstandard4th2g31 + PDstandard4th3g21));
-    
-    G231  =  khalf*(gu23*PDstandard4th1g33 + gu12*PDstandard4th3g11 + 
-          gu22*(PDstandard4th1g32 - PDstandard4th2g31 + PDstandard4th3g21));
-    
-    G331  =  khalf*(gu33*PDstandard4th1g33 + gu13*PDstandard4th3g11 + 
-          gu23*(PDstandard4th1g32 - PDstandard4th2g31 + PDstandard4th3g21));
-    
-    G122  =  khalf*(gu11*(-PDstandard4th1g22 + 2*PDstandard4th2g21) + gu12*PDstandard4th2g22 + 
-          gu13*(2*PDstandard4th2g32 - PDstandard4th3g22));
-    
-    G222  =  khalf*(gu12*(-PDstandard4th1g22 + 2*PDstandard4th2g21) + gu22*PDstandard4th2g22 + 
-          gu23*(2*PDstandard4th2g32 - PDstandard4th3g22));
-    
-    G322  =  khalf*(gu13*(-PDstandard4th1g22 + 2*PDstandard4th2g21) + gu23*PDstandard4th2g22 + 
-          gu33*(2*PDstandard4th2g32 - PDstandard4th3g22));
-    
-    G132  =  khalf*(gu13*PDstandard4th2g33 + gu11*(-PDstandard4th1g32 + PDstandard4th2g31 + PDstandard4th3g21) + 
-          gu12*PDstandard4th3g22);
-    
-    G232  =  khalf*(gu23*PDstandard4th2g33 + gu12*(-PDstandard4th1g32 + PDstandard4th2g31 + PDstandard4th3g21) + 
-          gu22*PDstandard4th3g22);
-    
-    G332  =  khalf*(gu33*PDstandard4th2g33 + gu13*(-PDstandard4th1g32 + PDstandard4th2g31 + PDstandard4th3g21) + 
-          gu23*PDstandard4th3g22);
-    
-    G133  =  khalf*(-(gu11*PDstandard4th1g33) - gu12*PDstandard4th2g33 + 2*gu11*PDstandard4th3g31 + 
-          2*gu12*PDstandard4th3g32 + gu13*PDstandard4th3g33);
-    
-    G233  =  khalf*(-(gu12*PDstandard4th1g33) - gu22*PDstandard4th2g33 + 2*gu12*PDstandard4th3g31 + 
-          2*gu22*PDstandard4th3g32 + gu23*PDstandard4th3g33);
-    
-    G333  =  khalf*(-(gu13*PDstandard4th1g33) - gu23*PDstandard4th2g33 + 2*gu13*PDstandard4th3g31 + 
-          2*gu23*PDstandard4th3g32 + gu33*PDstandard4th3g33);
-    
-    R11  =  khalf*(4*G231*G321 + G211*(2*G121 - 2*G222 - 2*G332) + G311*(2*G131 - 2*G333) - gu22*PDstandard4th11g22 - 
-          2*(G111*G221 + G232*G311 + G111*G331 + gu23*PDstandard4th11g32) - gu33*PDstandard4th11g33 + 
-          2*gu22*PDstandard4th12g21 + 2*gu23*PDstandard4th12g31 + 2*gu23*PDstandard4th13g21 + 2*gu33*PDstandard4th13g31 - 
-          gu22*PDstandard4th22g11 - 2*gu23*PDstandard4th23g11 - gu33*PDstandard4th33g11 + 2*SQR(G221) + 2*SQR(G331));
-    
-    R21  =  khalf*(2*(G122*G211 + G132*G311 + G231*G322 + G331*G332) - 
-          2*(G121*G221 + G121*G331 + G221*G332 + G321*G333 + gu12*PDstandard4th12g21) - gu23*PDstandard4th12g32 - 
-          gu33*PDstandard4th12g33 + gu13*(PDstandard4th11g32 - PDstandard4th12g31 - PDstandard4th13g21) + 
-          gu23*PDstandard4th13g22 + gu33*PDstandard4th13g32 + gu12*(PDstandard4th11g22 + PDstandard4th22g11) + 
-          gu23*PDstandard4th22g31 + gu13*PDstandard4th23g11 - gu23*PDstandard4th23g21 + gu33*PDstandard4th23g31 - 
-          gu33*PDstandard4th33g21);
-    
-    R31  =  khalf*(2*(G132*G211 + G221*G232 + G133*G311 + G233*G321) - 
-          2*(G222*G231 + G232*G331 + G131*(G221 + G331) + gu13*PDstandard4th13g31) + 
-          gu12*(PDstandard4th11g32 - PDstandard4th12g31 - PDstandard4th13g21 + PDstandard4th23g11) + 
-          gu22*(PDstandard4th12g32 - PDstandard4th13g22 - PDstandard4th22g31 + PDstandard4th23g21) + 
-          gu13*(PDstandard4th11g33 + PDstandard4th33g11) + 
-          gu23*(PDstandard4th12g33 - PDstandard4th13g32 - PDstandard4th23g31 + PDstandard4th33g21));
-    
-    R22  =  khalf*(4*G132*G321 + G122*(2*G221 - 2*(G111 + G331)) + G322*(2*G232 - 2*G333) - 
-          2*(G131*G322 + G222*(G121 + G332) + gu13*PDstandard4th13g22) + 
-          gu11*(-PDstandard4th11g22 + 2*PDstandard4th12g21 - PDstandard4th22g11) + 
-          gu13*(-2*PDstandard4th22g31 + 2*(PDstandard4th12g32 + PDstandard4th23g21)) + 
-          gu33*(-PDstandard4th22g33 + 2*PDstandard4th23g32 - PDstandard4th33g22) + 2*(SQR(G121) + SQR(G332)));
-    
-    R32  =  khalf*(2*(G121*G131 + G122*G231 + G133*G321 + G233*G322) + 
-          gu11*(-PDstandard4th11g32 + PDstandard4th12g31 + PDstandard4th13g21 - PDstandard4th23g11) + 
-          gu12*(-PDstandard4th12g32 + PDstandard4th13g22 + PDstandard4th22g31 - PDstandard4th23g21) - 
-          2*(G111*G132 + G131*G332 + G232*(G121 + G332) + gu23*PDstandard4th23g32) + 
-          gu13*(PDstandard4th12g33 - PDstandard4th13g32 - PDstandard4th23g31 + PDstandard4th33g21) + 
-          gu23*(PDstandard4th22g33 + PDstandard4th33g22));
-    
-    R33  =  khalf*(4*G132*G231 - gu11*PDstandard4th11g33 - 
-          2*(G111*G133 + G133*G221 + G121*G233 + G222*G233 + G131*G333 + G232*G333 + gu12*PDstandard4th12g33) + 
-          2*(G133*G331 + G233*G332 + gu11*PDstandard4th13g31) + 2*gu12*PDstandard4th13g32 - gu22*PDstandard4th22g33 + 
-          2*gu12*PDstandard4th23g31 + 2*gu22*PDstandard4th23g32 - gu11*PDstandard4th33g11 - 2*gu12*PDstandard4th33g21 - 
-          gu22*PDstandard4th33g22 + 2*SQR(G131) + 2*SQR(G232));
-    
-    Km11  =  gu11*K11L + gu12*K21L + gu13*K31L;
-    
-    Km21  =  gu12*K11L + gu22*K21L + gu23*K31L;
-    
-    Km31  =  gu13*K11L + gu23*K21L + gu33*K31L;
-    
-    Km12  =  gu11*K21L + gu12*K22L + gu13*K32L;
-    
-    Km22  =  gu12*K21L + gu22*K22L + gu23*K32L;
-    
-    Km32  =  gu13*K21L + gu23*K22L + gu33*K32L;
-    
-    Km13  =  gu11*K31L + gu12*K32L + gu13*K33L;
-    
-    Km23  =  gu12*K31L + gu22*K32L + gu23*K33L;
-    
-    Km33  =  gu13*K31L + gu23*K32L + gu33*K33L;
-    
-    trK  =  Km11 + Km22 + Km33;
-    
-    g11rhsL  =  -2*alphaL*K11L + 2*(g11L*PDstandard4th1beta1 + g21L*PDstandard4th1beta2 + g31L*PDstandard4th1beta3) + 
-        beta1L*PDstandard4th1g11 + beta2L*PDstandard4th2g11 + beta3L*PDstandard4th3g11;
-    
-    g21rhsL  =  -2*alphaL*K21L + g22L*PDstandard4th1beta2 + g32L*PDstandard4th1beta3 + beta1L*PDstandard4th1g21 + 
-        g11L*PDstandard4th2beta1 + g21L*(PDstandard4th1beta1 + PDstandard4th2beta2) + g31L*PDstandard4th2beta3 + 
-        beta2L*PDstandard4th2g21 + beta3L*PDstandard4th3g21;
-    
-    g31rhsL  =  -2*alphaL*K31L + g32L*PDstandard4th1beta2 + g33L*PDstandard4th1beta3 + beta1L*PDstandard4th1g31 + 
-        beta2L*PDstandard4th2g31 + g11L*PDstandard4th3beta1 + g21L*PDstandard4th3beta2 + 
-        g31L*(PDstandard4th1beta1 + PDstandard4th3beta3) + beta3L*PDstandard4th3g31;
-    
-    g22rhsL  =  -2*alphaL*K22L + beta1L*PDstandard4th1g22 + 
-        2*(g21L*PDstandard4th2beta1 + g22L*PDstandard4th2beta2 + g32L*PDstandard4th2beta3) + beta2L*PDstandard4th2g22 + 
-        beta3L*PDstandard4th3g22;
-    
-    g32rhsL  =  -2*alphaL*K32L + beta1L*PDstandard4th1g32 + g31L*PDstandard4th2beta1 + g33L*PDstandard4th2beta3 + 
-        beta2L*PDstandard4th2g32 + g21L*PDstandard4th3beta1 + g22L*PDstandard4th3beta2 + 
-        g32L*(PDstandard4th2beta2 + PDstandard4th3beta3) + beta3L*PDstandard4th3g32;
-    
-    g33rhsL  =  -2*alphaL*K33L + beta1L*PDstandard4th1g33 + beta2L*PDstandard4th2g33 + 
-        2*(g31L*PDstandard4th3beta1 + g32L*PDstandard4th3beta2 + g33L*PDstandard4th3beta3) + beta3L*PDstandard4th3g33;
-    
-    K11rhsL  =  -PDstandard4th11alpha + G111*PDstandard4th1alpha + 
-        2*(K11L*PDstandard4th1beta1 + K21L*PDstandard4th1beta2 + K31L*PDstandard4th1beta3) + beta1L*PDstandard4th1K11 + 
-        G211*PDstandard4th2alpha + beta2L*PDstandard4th2K11 + G311*PDstandard4th3alpha + beta3L*PDstandard4th3K11 + 
-        alphaL*(-2*(K11L*Km11 + K21L*Km21 + K31L*Km31) + R11 + K11L*trK);
-    
-    K21rhsL  =  -PDstandard4th12alpha + G121*PDstandard4th1alpha + K22L*PDstandard4th1beta2 + K32L*PDstandard4th1beta3 + 
-        beta1L*PDstandard4th1K21 + G221*PDstandard4th2alpha + K11L*PDstandard4th2beta1 + 
-        K21L*(PDstandard4th1beta1 + PDstandard4th2beta2) + K31L*PDstandard4th2beta3 + beta2L*PDstandard4th2K21 + 
-        G321*PDstandard4th3alpha + beta3L*PDstandard4th3K21 + 
-        alphaL*(-2*(K11L*Km12 + K21L*Km22 + K31L*Km32) + R21 + K21L*trK);
-    
-    K31rhsL  =  -PDstandard4th13alpha + G131*PDstandard4th1alpha + K32L*PDstandard4th1beta2 + K33L*PDstandard4th1beta3 + 
-        beta1L*PDstandard4th1K31 + G231*PDstandard4th2alpha + beta2L*PDstandard4th2K31 + G331*PDstandard4th3alpha + 
-        K11L*PDstandard4th3beta1 + K21L*PDstandard4th3beta2 + K31L*(PDstandard4th1beta1 + PDstandard4th3beta3) + 
-        beta3L*PDstandard4th3K31 + alphaL*(-2*(K11L*Km13 + K21L*Km23 + K31L*Km33) + R31 + K31L*trK);
-    
-    K22rhsL  =  G122*PDstandard4th1alpha + beta1L*PDstandard4th1K22 - PDstandard4th22alpha + G222*PDstandard4th2alpha + 
-        2*(K21L*PDstandard4th2beta1 + K22L*PDstandard4th2beta2 + K32L*PDstandard4th2beta3) + beta2L*PDstandard4th2K22 + 
-        G322*PDstandard4th3alpha + beta3L*PDstandard4th3K22 + 
-        alphaL*(-2*(K21L*Km12 + K22L*Km22 + K32L*Km32) + R22 + K22L*trK);
-    
-    K32rhsL  =  G132*PDstandard4th1alpha + beta1L*PDstandard4th1K32 - PDstandard4th23alpha + G232*PDstandard4th2alpha + 
-        K31L*PDstandard4th2beta1 + K33L*PDstandard4th2beta3 + beta2L*PDstandard4th2K32 + G332*PDstandard4th3alpha + 
-        K21L*PDstandard4th3beta1 + K22L*PDstandard4th3beta2 + K32L*(PDstandard4th2beta2 + PDstandard4th3beta3) + 
-        beta3L*PDstandard4th3K32 + alphaL*(-2*(K21L*Km13 + K22L*Km23 + K32L*Km33) + R32 + K32L*trK);
-    
-    K33rhsL  =  G133*PDstandard4th1alpha + beta1L*PDstandard4th1K33 + G233*PDstandard4th2alpha + beta2L*PDstandard4th2K33 - 
-        PDstandard4th33alpha + G333*PDstandard4th3alpha + 
-        2*(K31L*PDstandard4th3beta1 + K32L*PDstandard4th3beta2 + K33L*PDstandard4th3beta3) + beta3L*PDstandard4th3K33 + 
-        alphaL*(-2*(K31L*Km13 + K32L*Km23 + K33L*Km33) + R33 + K33L*trK);
-    
-    alpharhsL  =  0;
-    
-    beta1rhsL  =  0;
-    
-    beta2rhsL  =  0;
-    
-    beta3rhsL  =  0;
-    
-    
-    /* Copy local copies back to grid functions */
-    alpharhs[index] = alpharhsL;
-    beta1rhs[index] = beta1rhsL;
-    beta2rhs[index] = beta2rhsL;
-    beta3rhs[index] = beta3rhsL;
-    g11rhs[index] = g11rhsL;
-    g21rhs[index] = g21rhsL;
-    g22rhs[index] = g22rhsL;
-    g31rhs[index] = g31rhsL;
-    g32rhs[index] = g32rhsL;
-    g33rhs[index] = g33rhsL;
-    K11rhs[index] = K11rhsL;
-    K21rhs[index] = K21rhsL;
-    K22rhs[index] = K22rhsL;
-    K31rhs[index] = K31rhsL;
-    K32rhs[index] = K32rhsL;
-    K33rhs[index] = K33rhsL;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_ADM_RHS(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverEverything(cctkGH, &ML_ADM_RHS_Body);
-}
diff --git a/m/ML_ADM/src/ML_ADM_constraints.c b/m/ML_ADM/src/ML_ADM_constraints.c
deleted file mode 100644
index 420fbe7..0000000
--- a/m/ML_ADM/src/ML_ADM_constraints.c
+++ /dev/null
@@ -1,445 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_ADM_constraints_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_ADM_constraints_Body");
-  }
-  
-  if (cctk_iteration % ML_ADM_constraints_calc_every != ML_ADM_constraints_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    CCTK_REAL detg = INITVALUE;
-    CCTK_REAL G111 = INITVALUE, G121 = INITVALUE, G122 = INITVALUE, G131 = INITVALUE, G132 = INITVALUE, G133 = INITVALUE;
-    CCTK_REAL G211 = INITVALUE, G221 = INITVALUE, G222 = INITVALUE, G231 = INITVALUE, G232 = INITVALUE, G233 = INITVALUE;
-    CCTK_REAL G311 = INITVALUE, G321 = INITVALUE, G322 = INITVALUE, G331 = INITVALUE, G332 = INITVALUE, G333 = INITVALUE;
-    CCTK_REAL gu11 = INITVALUE, gu12 = INITVALUE, gu13 = INITVALUE, gu22 = INITVALUE, gu23 = INITVALUE, gu33 = INITVALUE;
-    CCTK_REAL Km11 = INITVALUE, Km12 = INITVALUE, Km13 = INITVALUE, Km21 = INITVALUE, Km22 = INITVALUE, Km23 = INITVALUE;
-    CCTK_REAL Km31 = INITVALUE, Km32 = INITVALUE, Km33 = INITVALUE;
-    CCTK_REAL R11 = INITVALUE, R21 = INITVALUE, R22 = INITVALUE, R31 = INITVALUE, R32 = INITVALUE, R33 = INITVALUE;
-    CCTK_REAL trK = INITVALUE;
-    CCTK_REAL trR = INITVALUE;
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL g11L = INITVALUE, g21L = INITVALUE, g22L = INITVALUE, g31L = INITVALUE, g32L = INITVALUE, g33L = INITVALUE;
-    CCTK_REAL HL = INITVALUE;
-    CCTK_REAL K11L = INITVALUE, K21L = INITVALUE, K22L = INITVALUE, K31L = INITVALUE, K32L = INITVALUE, K33L = INITVALUE;
-    CCTK_REAL M1L = INITVALUE, M2L = INITVALUE, M3L = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    CCTK_REAL PDstandard4th1g11 = INITVALUE;
-    CCTK_REAL PDstandard4th2g11 = INITVALUE;
-    CCTK_REAL PDstandard4th3g11 = INITVALUE;
-    CCTK_REAL PDstandard4th22g11 = INITVALUE;
-    CCTK_REAL PDstandard4th33g11 = INITVALUE;
-    CCTK_REAL PDstandard4th12g11 = INITVALUE;
-    CCTK_REAL PDstandard4th13g11 = INITVALUE;
-    CCTK_REAL PDstandard4th21g11 = INITVALUE;
-    CCTK_REAL PDstandard4th23g11 = INITVALUE;
-    CCTK_REAL PDstandard4th31g11 = INITVALUE;
-    CCTK_REAL PDstandard4th32g11 = INITVALUE;
-    CCTK_REAL PDstandard4th1g21 = INITVALUE;
-    CCTK_REAL PDstandard4th2g21 = INITVALUE;
-    CCTK_REAL PDstandard4th3g21 = INITVALUE;
-    CCTK_REAL PDstandard4th33g21 = INITVALUE;
-    CCTK_REAL PDstandard4th12g21 = INITVALUE;
-    CCTK_REAL PDstandard4th13g21 = INITVALUE;
-    CCTK_REAL PDstandard4th21g21 = INITVALUE;
-    CCTK_REAL PDstandard4th23g21 = INITVALUE;
-    CCTK_REAL PDstandard4th31g21 = INITVALUE;
-    CCTK_REAL PDstandard4th32g21 = INITVALUE;
-    CCTK_REAL PDstandard4th1g22 = INITVALUE;
-    CCTK_REAL PDstandard4th2g22 = INITVALUE;
-    CCTK_REAL PDstandard4th3g22 = INITVALUE;
-    CCTK_REAL PDstandard4th11g22 = INITVALUE;
-    CCTK_REAL PDstandard4th33g22 = INITVALUE;
-    CCTK_REAL PDstandard4th12g22 = INITVALUE;
-    CCTK_REAL PDstandard4th13g22 = INITVALUE;
-    CCTK_REAL PDstandard4th21g22 = INITVALUE;
-    CCTK_REAL PDstandard4th23g22 = INITVALUE;
-    CCTK_REAL PDstandard4th31g22 = INITVALUE;
-    CCTK_REAL PDstandard4th32g22 = INITVALUE;
-    CCTK_REAL PDstandard4th1g31 = INITVALUE;
-    CCTK_REAL PDstandard4th2g31 = INITVALUE;
-    CCTK_REAL PDstandard4th3g31 = INITVALUE;
-    CCTK_REAL PDstandard4th22g31 = INITVALUE;
-    CCTK_REAL PDstandard4th12g31 = INITVALUE;
-    CCTK_REAL PDstandard4th13g31 = INITVALUE;
-    CCTK_REAL PDstandard4th21g31 = INITVALUE;
-    CCTK_REAL PDstandard4th23g31 = INITVALUE;
-    CCTK_REAL PDstandard4th31g31 = INITVALUE;
-    CCTK_REAL PDstandard4th32g31 = INITVALUE;
-    CCTK_REAL PDstandard4th1g32 = INITVALUE;
-    CCTK_REAL PDstandard4th2g32 = INITVALUE;
-    CCTK_REAL PDstandard4th3g32 = INITVALUE;
-    CCTK_REAL PDstandard4th11g32 = INITVALUE;
-    CCTK_REAL PDstandard4th12g32 = INITVALUE;
-    CCTK_REAL PDstandard4th13g32 = INITVALUE;
-    CCTK_REAL PDstandard4th21g32 = INITVALUE;
-    CCTK_REAL PDstandard4th23g32 = INITVALUE;
-    CCTK_REAL PDstandard4th31g32 = INITVALUE;
-    CCTK_REAL PDstandard4th32g32 = INITVALUE;
-    CCTK_REAL PDstandard4th1g33 = INITVALUE;
-    CCTK_REAL PDstandard4th2g33 = INITVALUE;
-    CCTK_REAL PDstandard4th3g33 = INITVALUE;
-    CCTK_REAL PDstandard4th11g33 = INITVALUE;
-    CCTK_REAL PDstandard4th22g33 = INITVALUE;
-    CCTK_REAL PDstandard4th12g33 = INITVALUE;
-    CCTK_REAL PDstandard4th13g33 = INITVALUE;
-    CCTK_REAL PDstandard4th21g33 = INITVALUE;
-    CCTK_REAL PDstandard4th23g33 = INITVALUE;
-    CCTK_REAL PDstandard4th31g33 = INITVALUE;
-    CCTK_REAL PDstandard4th32g33 = INITVALUE;
-    CCTK_REAL PDstandard4th2K11 = INITVALUE;
-    CCTK_REAL PDstandard4th3K11 = INITVALUE;
-    CCTK_REAL PDstandard4th1K21 = INITVALUE;
-    CCTK_REAL PDstandard4th2K21 = INITVALUE;
-    CCTK_REAL PDstandard4th3K21 = INITVALUE;
-    CCTK_REAL PDstandard4th1K22 = INITVALUE;
-    CCTK_REAL PDstandard4th3K22 = INITVALUE;
-    CCTK_REAL PDstandard4th1K31 = INITVALUE;
-    CCTK_REAL PDstandard4th2K31 = INITVALUE;
-    CCTK_REAL PDstandard4th3K31 = INITVALUE;
-    CCTK_REAL PDstandard4th1K32 = INITVALUE;
-    CCTK_REAL PDstandard4th2K32 = INITVALUE;
-    CCTK_REAL PDstandard4th3K32 = INITVALUE;
-    CCTK_REAL PDstandard4th1K33 = INITVALUE;
-    CCTK_REAL PDstandard4th2K33 = INITVALUE;
-    
-    /* Assign local copies of grid functions */
-    g11L = g11[index];
-    g21L = g21[index];
-    g22L = g22[index];
-    g31L = g31[index];
-    g32L = g32[index];
-    g33L = g33[index];
-    K11L = K11[index];
-    K21L = K21[index];
-    K22L = K22[index];
-    K31L = K31[index];
-    K32L = K32[index];
-    K33L = K33[index];
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    PDstandard4th1g11 = PDstandard4th1(g11, i, j, k);
-    PDstandard4th2g11 = PDstandard4th2(g11, i, j, k);
-    PDstandard4th3g11 = PDstandard4th3(g11, i, j, k);
-    PDstandard4th22g11 = PDstandard4th22(g11, i, j, k);
-    PDstandard4th33g11 = PDstandard4th33(g11, i, j, k);
-    PDstandard4th23g11 = PDstandard4th23(g11, i, j, k);
-    PDstandard4th1g21 = PDstandard4th1(g21, i, j, k);
-    PDstandard4th2g21 = PDstandard4th2(g21, i, j, k);
-    PDstandard4th3g21 = PDstandard4th3(g21, i, j, k);
-    PDstandard4th33g21 = PDstandard4th33(g21, i, j, k);
-    PDstandard4th12g21 = PDstandard4th12(g21, i, j, k);
-    PDstandard4th13g21 = PDstandard4th13(g21, i, j, k);
-    PDstandard4th23g21 = PDstandard4th23(g21, i, j, k);
-    PDstandard4th1g22 = PDstandard4th1(g22, i, j, k);
-    PDstandard4th2g22 = PDstandard4th2(g22, i, j, k);
-    PDstandard4th3g22 = PDstandard4th3(g22, i, j, k);
-    PDstandard4th11g22 = PDstandard4th11(g22, i, j, k);
-    PDstandard4th33g22 = PDstandard4th33(g22, i, j, k);
-    PDstandard4th13g22 = PDstandard4th13(g22, i, j, k);
-    PDstandard4th1g31 = PDstandard4th1(g31, i, j, k);
-    PDstandard4th2g31 = PDstandard4th2(g31, i, j, k);
-    PDstandard4th3g31 = PDstandard4th3(g31, i, j, k);
-    PDstandard4th22g31 = PDstandard4th22(g31, i, j, k);
-    PDstandard4th12g31 = PDstandard4th12(g31, i, j, k);
-    PDstandard4th13g31 = PDstandard4th13(g31, i, j, k);
-    PDstandard4th23g31 = PDstandard4th23(g31, i, j, k);
-    PDstandard4th1g32 = PDstandard4th1(g32, i, j, k);
-    PDstandard4th2g32 = PDstandard4th2(g32, i, j, k);
-    PDstandard4th3g32 = PDstandard4th3(g32, i, j, k);
-    PDstandard4th11g32 = PDstandard4th11(g32, i, j, k);
-    PDstandard4th12g32 = PDstandard4th12(g32, i, j, k);
-    PDstandard4th13g32 = PDstandard4th13(g32, i, j, k);
-    PDstandard4th23g32 = PDstandard4th23(g32, i, j, k);
-    PDstandard4th1g33 = PDstandard4th1(g33, i, j, k);
-    PDstandard4th2g33 = PDstandard4th2(g33, i, j, k);
-    PDstandard4th3g33 = PDstandard4th3(g33, i, j, k);
-    PDstandard4th11g33 = PDstandard4th11(g33, i, j, k);
-    PDstandard4th22g33 = PDstandard4th22(g33, i, j, k);
-    PDstandard4th12g33 = PDstandard4th12(g33, i, j, k);
-    PDstandard4th2K11 = PDstandard4th2(K11, i, j, k);
-    PDstandard4th3K11 = PDstandard4th3(K11, i, j, k);
-    PDstandard4th1K21 = PDstandard4th1(K21, i, j, k);
-    PDstandard4th2K21 = PDstandard4th2(K21, i, j, k);
-    PDstandard4th3K21 = PDstandard4th3(K21, i, j, k);
-    PDstandard4th1K22 = PDstandard4th1(K22, i, j, k);
-    PDstandard4th3K22 = PDstandard4th3(K22, i, j, k);
-    PDstandard4th1K31 = PDstandard4th1(K31, i, j, k);
-    PDstandard4th2K31 = PDstandard4th2(K31, i, j, k);
-    PDstandard4th3K31 = PDstandard4th3(K31, i, j, k);
-    PDstandard4th1K32 = PDstandard4th1(K32, i, j, k);
-    PDstandard4th2K32 = PDstandard4th2(K32, i, j, k);
-    PDstandard4th3K32 = PDstandard4th3(K32, i, j, k);
-    PDstandard4th1K33 = PDstandard4th1(K33, i, j, k);
-    PDstandard4th2K33 = PDstandard4th2(K33, i, j, k);
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    detg  =  2*g21L*g31L*g32L + g33L*(g11L*g22L - SQR(g21L)) - g22L*SQR(g31L) - g11L*SQR(g32L);
-    
-    gu11  =  INV(detg)*(g22L*g33L - SQR(g32L));
-    
-    gu12  =  (g31L*g32L - g21L*g33L)*INV(detg);
-    
-    gu13  =  (-(g22L*g31L) + g21L*g32L)*INV(detg);
-    
-    gu22  =  INV(detg)*(g11L*g33L - SQR(g31L));
-    
-    gu23  =  (g21L*g31L - g11L*g32L)*INV(detg);
-    
-    gu33  =  INV(detg)*(g11L*g22L - SQR(g21L));
-    
-    G111  =  khalf*(gu11*PDstandard4th1g11 + 2*(gu12*PDstandard4th1g21 + gu13*PDstandard4th1g31) - gu12*PDstandard4th2g11 - 
-          gu13*PDstandard4th3g11);
-    
-    G211  =  khalf*(gu12*PDstandard4th1g11 + 2*(gu22*PDstandard4th1g21 + gu23*PDstandard4th1g31) - gu22*PDstandard4th2g11 - 
-          gu23*PDstandard4th3g11);
-    
-    G311  =  khalf*(gu13*PDstandard4th1g11 + 2*(gu23*PDstandard4th1g21 + gu33*PDstandard4th1g31) - gu23*PDstandard4th2g11 - 
-          gu33*PDstandard4th3g11);
-    
-    G121  =  khalf*(gu12*PDstandard4th1g22 + gu11*PDstandard4th2g11 + 
-          gu13*(PDstandard4th1g32 + PDstandard4th2g31 - PDstandard4th3g21));
-    
-    G221  =  khalf*(gu22*PDstandard4th1g22 + gu12*PDstandard4th2g11 + 
-          gu23*(PDstandard4th1g32 + PDstandard4th2g31 - PDstandard4th3g21));
-    
-    G321  =  khalf*(gu23*PDstandard4th1g22 + gu13*PDstandard4th2g11 + 
-          gu33*(PDstandard4th1g32 + PDstandard4th2g31 - PDstandard4th3g21));
-    
-    G131  =  khalf*(gu13*PDstandard4th1g33 + gu11*PDstandard4th3g11 + 
-          gu12*(PDstandard4th1g32 - PDstandard4th2g31 + PDstandard4th3g21));
-    
-    G231  =  khalf*(gu23*PDstandard4th1g33 + gu12*PDstandard4th3g11 + 
-          gu22*(PDstandard4th1g32 - PDstandard4th2g31 + PDstandard4th3g21));
-    
-    G331  =  khalf*(gu33*PDstandard4th1g33 + gu13*PDstandard4th3g11 + 
-          gu23*(PDstandard4th1g32 - PDstandard4th2g31 + PDstandard4th3g21));
-    
-    G122  =  khalf*(gu11*(-PDstandard4th1g22 + 2*PDstandard4th2g21) + gu12*PDstandard4th2g22 + 
-          gu13*(2*PDstandard4th2g32 - PDstandard4th3g22));
-    
-    G222  =  khalf*(gu12*(-PDstandard4th1g22 + 2*PDstandard4th2g21) + gu22*PDstandard4th2g22 + 
-          gu23*(2*PDstandard4th2g32 - PDstandard4th3g22));
-    
-    G322  =  khalf*(gu13*(-PDstandard4th1g22 + 2*PDstandard4th2g21) + gu23*PDstandard4th2g22 + 
-          gu33*(2*PDstandard4th2g32 - PDstandard4th3g22));
-    
-    G132  =  khalf*(gu13*PDstandard4th2g33 + gu11*(-PDstandard4th1g32 + PDstandard4th2g31 + PDstandard4th3g21) + 
-          gu12*PDstandard4th3g22);
-    
-    G232  =  khalf*(gu23*PDstandard4th2g33 + gu12*(-PDstandard4th1g32 + PDstandard4th2g31 + PDstandard4th3g21) + 
-          gu22*PDstandard4th3g22);
-    
-    G332  =  khalf*(gu33*PDstandard4th2g33 + gu13*(-PDstandard4th1g32 + PDstandard4th2g31 + PDstandard4th3g21) + 
-          gu23*PDstandard4th3g22);
-    
-    G133  =  khalf*(-(gu11*PDstandard4th1g33) - gu12*PDstandard4th2g33 + 2*gu11*PDstandard4th3g31 + 
-          2*gu12*PDstandard4th3g32 + gu13*PDstandard4th3g33);
-    
-    G233  =  khalf*(-(gu12*PDstandard4th1g33) - gu22*PDstandard4th2g33 + 2*gu12*PDstandard4th3g31 + 
-          2*gu22*PDstandard4th3g32 + gu23*PDstandard4th3g33);
-    
-    G333  =  khalf*(-(gu13*PDstandard4th1g33) - gu23*PDstandard4th2g33 + 2*gu13*PDstandard4th3g31 + 
-          2*gu23*PDstandard4th3g32 + gu33*PDstandard4th3g33);
-    
-    R11  =  khalf*(-(gu22*PDstandard4th11g22) - 2*(G111*G122 + G111*G133 + G211*G222 + G211*G233 + G311*G322 + G311*G333 + 
-             gu23*PDstandard4th11g32) - gu33*PDstandard4th11g33 + 2*gu22*PDstandard4th12g21 + 2*gu23*PDstandard4th12g31 + 
-          2*gu23*PDstandard4th13g21 + 2*gu33*PDstandard4th13g31 - gu22*PDstandard4th22g11 - 2*gu23*PDstandard4th23g11 - 
-          gu33*PDstandard4th33g11 + 2*SQR(G121) + 2*SQR(G131) + 2*SQR(G221) + 2*SQR(G231) + 2*SQR(G321) + 2*SQR(G331));
-    
-    R21  =  khalf*(2*(G131*G132 + G231*G232 + G331*G332) - 2*(G121*G133 + G221*G233 + G321*G333 + gu12*PDstandard4th12g21) - 
-          gu23*PDstandard4th12g32 - gu33*PDstandard4th12g33 + 
-          gu13*(PDstandard4th11g32 - PDstandard4th12g31 - PDstandard4th13g21) + gu23*PDstandard4th13g22 + 
-          gu33*PDstandard4th13g32 + gu12*(PDstandard4th11g22 + PDstandard4th22g11) + gu23*PDstandard4th22g31 + 
-          gu13*PDstandard4th23g11 - gu23*PDstandard4th23g21 + gu33*PDstandard4th23g31 - gu33*PDstandard4th33g21);
-    
-    R31  =  khalf*(2*(G121*G132 + G221*G232 + G321*G332) - 2*(G122*G131 + G222*G231 + G322*G331 + gu13*PDstandard4th13g31) + 
-          gu12*(PDstandard4th11g32 - PDstandard4th12g31 - PDstandard4th13g21 + PDstandard4th23g11) + 
-          gu22*(PDstandard4th12g32 - PDstandard4th13g22 - PDstandard4th22g31 + PDstandard4th23g21) + 
-          gu13*(PDstandard4th11g33 + PDstandard4th33g11) + 
-          gu23*(PDstandard4th12g33 - PDstandard4th13g32 - PDstandard4th23g31 + PDstandard4th33g21));
-    
-    R22  =  khalf*(-2*(G122*(G111 + G133) + G222*(G211 + G233) + G322*(G311 + G333) + gu13*PDstandard4th13g22) + 
-          gu11*(-PDstandard4th11g22 + 2*PDstandard4th12g21 - PDstandard4th22g11) + 
-          gu13*(-2*PDstandard4th22g31 + 2*(PDstandard4th12g32 + PDstandard4th23g21)) + 
-          gu33*(-PDstandard4th22g33 + 2*PDstandard4th23g32 - PDstandard4th33g22) + 
-          2*(SQR(G121) + SQR(G132) + SQR(G221) + SQR(G232) + SQR(G321) + SQR(G332)));
-    
-    R32  =  khalf*(2*(G121*G131 + G221*G231 + G321*G331) + 
-          gu11*(-PDstandard4th11g32 + PDstandard4th12g31 + PDstandard4th13g21 - PDstandard4th23g11) + 
-          gu12*(-PDstandard4th12g32 + PDstandard4th13g22 + PDstandard4th22g31 - PDstandard4th23g21) - 
-          2*(G111*G132 + G211*G232 + G311*G332 + gu23*PDstandard4th23g32) + 
-          gu13*(PDstandard4th12g33 - PDstandard4th13g32 - PDstandard4th23g31 + PDstandard4th33g21) + 
-          gu23*(PDstandard4th22g33 + PDstandard4th33g22));
-    
-    R33  =  khalf*(gu11*(-PDstandard4th11g33 + 2*PDstandard4th13g31 - PDstandard4th33g11) - 
-          2*((G111 + G122)*G133 + (G211 + G222)*G233 + (G311 + G322)*G333 + 
-             gu12*(PDstandard4th12g33 + PDstandard4th33g21)) + 
-          gu22*(-PDstandard4th22g33 + 2*PDstandard4th23g32 - PDstandard4th33g22) + 
-          2*(gu12*(PDstandard4th13g32 + PDstandard4th23g31) + SQR(G131) + SQR(G132) + SQR(G231) + SQR(G232) + SQR(G331) + 
-             SQR(G332)));
-    
-    trR  =  gu11*R11 + gu22*R22 + 2*(gu12*R21 + gu13*R31 + gu23*R32) + gu33*R33;
-    
-    Km11  =  gu11*K11L + gu12*K21L + gu13*K31L;
-    
-    Km21  =  gu12*K11L + gu22*K21L + gu23*K31L;
-    
-    Km31  =  gu13*K11L + gu23*K21L + gu33*K31L;
-    
-    Km12  =  gu11*K21L + gu12*K22L + gu13*K32L;
-    
-    Km22  =  gu12*K21L + gu22*K22L + gu23*K32L;
-    
-    Km32  =  gu13*K21L + gu23*K22L + gu33*K32L;
-    
-    Km13  =  gu11*K31L + gu12*K32L + gu13*K33L;
-    
-    Km23  =  gu12*K31L + gu22*K32L + gu23*K33L;
-    
-    Km33  =  gu13*K31L + gu23*K32L + gu33*K33L;
-    
-    trK  =  Km11 + Km22 + Km33;
-    
-    HL  =  -2*(Km12*Km21 + Km13*Km31 + Km23*Km32) + trR - SQR(Km11) - SQR(Km22) - SQR(Km33) + SQR(trK);
-    
-    M1L  =  gu12*(-(G121*K11L) + G111*K21L - G221*K21L + G211*K22L - G321*K31L + G311*K32L - PDstandard4th1K21 + 
-           PDstandard4th2K11) + gu22*(-(G122*K11L) + G121*K21L - G222*K21L + G221*K22L - G322*K31L + G321*K32L - 
-           PDstandard4th1K22 + PDstandard4th2K21) + gu13*
-         (-(G131*K11L) - G231*K21L + G111*K31L - G331*K31L + G211*K32L + G311*K33L - PDstandard4th1K31 + PDstandard4th3K11)\
-         + gu23*(G131*K21L + G231*K22L + G121*K31L + (G221 + G331)*K32L + G321*K33L - 
-           2*(G132*K11L + G232*K21L + G332*K31L + PDstandard4th1K32) + PDstandard4th2K31 + PDstandard4th3K21) + 
-        gu33*(-(G133*K11L) - G233*K21L + G131*K31L - G333*K31L + G231*K32L + G331*K33L - PDstandard4th1K33 + 
-           PDstandard4th3K31);
-    
-    M2L  =  gu11*(G121*K11L + (-G111 + G221)*K21L - G211*K22L + G321*K31L - G311*K32L + PDstandard4th1K21 - 
-           PDstandard4th2K11) + gu12*(G122*K11L + (-G121 + G222)*K21L - G221*K22L + G322*K31L - G321*K32L + 
-           PDstandard4th1K22 - PDstandard4th2K21) + gu13*
-         (G132*K11L + (-2*G131 + G232)*K21L + (G121 + G332)*K31L + G221*K32L + G321*K33L + PDstandard4th1K32 - 
-           2*(G231*K22L + G331*K32L + PDstandard4th2K31) + PDstandard4th3K21) + 
-        gu23*(-(G132*K21L) - G232*K22L + G122*K31L + G222*K32L - G332*K32L + G322*K33L - PDstandard4th2K32 + 
-           PDstandard4th3K22) + gu33*(-(G133*K21L) - G233*K22L + G132*K31L + G232*K32L - G333*K32L + G332*K33L - 
-           PDstandard4th2K33 + PDstandard4th3K32);
-    
-    M3L  =  gu11*(G131*K11L + G231*K21L + (-G111 + G331)*K31L - G211*K32L - G311*K33L + PDstandard4th1K31 - 
-           PDstandard4th3K11) + gu12*(G132*K11L + (G131 + G232)*K21L + G231*K22L + (-2*G121 + G332)*K31L + 
-           (-2*G221 + G331)*K32L + PDstandard4th1K32 + PDstandard4th2K31 - 2*(G321*K33L + PDstandard4th3K21)) + 
-        gu22*(G132*K21L + G232*K22L - G122*K31L - G222*K32L + G332*K32L - G322*K33L + PDstandard4th2K32 - 
-           PDstandard4th3K22) + gu13*(G133*K11L + G233*K21L + (-G131 + G333)*K31L - G231*K32L - G331*K33L + 
-           PDstandard4th1K33 - PDstandard4th3K31) + gu23*
-         (G133*K21L + G233*K22L - G132*K31L - G232*K32L + G333*K32L - G332*K33L + PDstandard4th2K33 - PDstandard4th3K32);
-    
-    
-    /* Copy local copies back to grid functions */
-    H[index] = HL;
-    M1[index] = M1L;
-    M2[index] = M2L;
-    M3[index] = M3L;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_ADM_constraints(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverInterior(cctkGH, &ML_ADM_constraints_Body);
-}
diff --git a/m/ML_ADM/src/ML_ADM_convertFromADMBase.c b/m/ML_ADM/src/ML_ADM_convertFromADMBase.c
deleted file mode 100644
index a634aeb..0000000
--- a/m/ML_ADM/src/ML_ADM_convertFromADMBase.c
+++ /dev/null
@@ -1,212 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_ADM_convertFromADMBase_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_ADM_convertFromADMBase_Body");
-  }
-  
-  if (cctk_iteration % ML_ADM_convertFromADMBase_calc_every != ML_ADM_convertFromADMBase_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL alpL = INITVALUE;
-    CCTK_REAL alphaL = INITVALUE;
-    CCTK_REAL beta1L = INITVALUE, beta2L = INITVALUE, beta3L = INITVALUE;
-    CCTK_REAL betaxL = INITVALUE;
-    CCTK_REAL betayL = INITVALUE;
-    CCTK_REAL betazL = INITVALUE;
-    CCTK_REAL g11L = INITVALUE, g21L = INITVALUE, g22L = INITVALUE, g31L = INITVALUE, g32L = INITVALUE, g33L = INITVALUE;
-    CCTK_REAL gxxL = INITVALUE;
-    CCTK_REAL gxyL = INITVALUE;
-    CCTK_REAL gxzL = INITVALUE;
-    CCTK_REAL gyyL = INITVALUE;
-    CCTK_REAL gyzL = INITVALUE;
-    CCTK_REAL gzzL = INITVALUE;
-    CCTK_REAL K11L = INITVALUE, K21L = INITVALUE, K22L = INITVALUE, K31L = INITVALUE, K32L = INITVALUE, K33L = INITVALUE;
-    CCTK_REAL kxxL = INITVALUE;
-    CCTK_REAL kxyL = INITVALUE;
-    CCTK_REAL kxzL = INITVALUE;
-    CCTK_REAL kyyL = INITVALUE;
-    CCTK_REAL kyzL = INITVALUE;
-    CCTK_REAL kzzL = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    
-    /* Assign local copies of grid functions */
-    alpL = alp[index];
-    betaxL = betax[index];
-    betayL = betay[index];
-    betazL = betaz[index];
-    gxxL = gxx[index];
-    gxyL = gxy[index];
-    gxzL = gxz[index];
-    gyyL = gyy[index];
-    gyzL = gyz[index];
-    gzzL = gzz[index];
-    kxxL = kxx[index];
-    kxyL = kxy[index];
-    kxzL = kxz[index];
-    kyyL = kyy[index];
-    kyzL = kyz[index];
-    kzzL = kzz[index];
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    g11L  =  gxxL;
-    
-    g21L  =  gxyL;
-    
-    g31L  =  gxzL;
-    
-    g22L  =  gyyL;
-    
-    g32L  =  gyzL;
-    
-    g33L  =  gzzL;
-    
-    K11L  =  kxxL;
-    
-    K21L  =  kxyL;
-    
-    K31L  =  kxzL;
-    
-    K22L  =  kyyL;
-    
-    K32L  =  kyzL;
-    
-    K33L  =  kzzL;
-    
-    alphaL  =  alpL;
-    
-    beta1L  =  betaxL;
-    
-    beta2L  =  betayL;
-    
-    beta3L  =  betazL;
-    
-    
-    /* Copy local copies back to grid functions */
-    alpha[index] = alphaL;
-    beta1[index] = beta1L;
-    beta2[index] = beta2L;
-    beta3[index] = beta3L;
-    g11[index] = g11L;
-    g21[index] = g21L;
-    g22[index] = g22L;
-    g31[index] = g31L;
-    g32[index] = g32L;
-    g33[index] = g33L;
-    K11[index] = K11L;
-    K21[index] = K21L;
-    K22[index] = K22L;
-    K31[index] = K31L;
-    K32[index] = K32L;
-    K33[index] = K33L;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_ADM_convertFromADMBase(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverEverything(cctkGH, &ML_ADM_convertFromADMBase_Body);
-}
diff --git a/m/ML_ADM/src/ML_ADM_convertToADMBase.c b/m/ML_ADM/src/ML_ADM_convertToADMBase.c
deleted file mode 100644
index 5f010fb..0000000
--- a/m/ML_ADM/src/ML_ADM_convertToADMBase.c
+++ /dev/null
@@ -1,228 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_ADM_convertToADMBase_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_ADM_convertToADMBase_Body");
-  }
-  
-  if (cctk_iteration % ML_ADM_convertToADMBase_calc_every != ML_ADM_convertToADMBase_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL alpL = INITVALUE;
-    CCTK_REAL alphaL = INITVALUE;
-    CCTK_REAL beta1L = INITVALUE, beta2L = INITVALUE, beta3L = INITVALUE;
-    CCTK_REAL betaxL = INITVALUE;
-    CCTK_REAL betayL = INITVALUE;
-    CCTK_REAL betazL = INITVALUE;
-    CCTK_REAL dtalpL = INITVALUE;
-    CCTK_REAL dtbetaxL = INITVALUE;
-    CCTK_REAL dtbetayL = INITVALUE;
-    CCTK_REAL dtbetazL = INITVALUE;
-    CCTK_REAL g11L = INITVALUE, g21L = INITVALUE, g22L = INITVALUE, g31L = INITVALUE, g32L = INITVALUE, g33L = INITVALUE;
-    CCTK_REAL gxxL = INITVALUE;
-    CCTK_REAL gxyL = INITVALUE;
-    CCTK_REAL gxzL = INITVALUE;
-    CCTK_REAL gyyL = INITVALUE;
-    CCTK_REAL gyzL = INITVALUE;
-    CCTK_REAL gzzL = INITVALUE;
-    CCTK_REAL K11L = INITVALUE, K21L = INITVALUE, K22L = INITVALUE, K31L = INITVALUE, K32L = INITVALUE, K33L = INITVALUE;
-    CCTK_REAL kxxL = INITVALUE;
-    CCTK_REAL kxyL = INITVALUE;
-    CCTK_REAL kxzL = INITVALUE;
-    CCTK_REAL kyyL = INITVALUE;
-    CCTK_REAL kyzL = INITVALUE;
-    CCTK_REAL kzzL = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    
-    /* Assign local copies of grid functions */
-    alphaL = alpha[index];
-    beta1L = beta1[index];
-    beta2L = beta2[index];
-    beta3L = beta3[index];
-    g11L = g11[index];
-    g21L = g21[index];
-    g22L = g22[index];
-    g31L = g31[index];
-    g32L = g32[index];
-    g33L = g33[index];
-    K11L = K11[index];
-    K21L = K21[index];
-    K22L = K22[index];
-    K31L = K31[index];
-    K32L = K32[index];
-    K33L = K33[index];
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    gxxL  =  g11L;
-    
-    gxyL  =  g21L;
-    
-    gxzL  =  g31L;
-    
-    gyyL  =  g22L;
-    
-    gyzL  =  g32L;
-    
-    gzzL  =  g33L;
-    
-    kxxL  =  K11L;
-    
-    kxyL  =  K21L;
-    
-    kxzL  =  K31L;
-    
-    kyyL  =  K22L;
-    
-    kyzL  =  K32L;
-    
-    kzzL  =  K33L;
-    
-    alpL  =  alphaL;
-    
-    dtalpL  =  0;
-    
-    betaxL  =  beta1L;
-    
-    betayL  =  beta2L;
-    
-    betazL  =  beta3L;
-    
-    dtbetaxL  =  0;
-    
-    dtbetayL  =  0;
-    
-    dtbetazL  =  0;
-    
-    
-    /* Copy local copies back to grid functions */
-    alp[index] = alpL;
-    betax[index] = betaxL;
-    betay[index] = betayL;
-    betaz[index] = betazL;
-    dtalp[index] = dtalpL;
-    dtbetax[index] = dtbetaxL;
-    dtbetay[index] = dtbetayL;
-    dtbetaz[index] = dtbetazL;
-    gxx[index] = gxxL;
-    gxy[index] = gxyL;
-    gxz[index] = gxzL;
-    gyy[index] = gyyL;
-    gyz[index] = gyzL;
-    gzz[index] = gzzL;
-    kxx[index] = kxxL;
-    kxy[index] = kxyL;
-    kxz[index] = kxzL;
-    kyy[index] = kyyL;
-    kyz[index] = kyzL;
-    kzz[index] = kzzL;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_ADM_convertToADMBase(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverEverything(cctkGH, &ML_ADM_convertToADMBase_Body);
-}
diff --git a/m/ML_ADM/src/RegisterMoL.c b/m/ML_ADM/src/RegisterMoL.c
deleted file mode 100644
index a87e176..0000000
--- a/m/ML_ADM/src/RegisterMoL.c
+++ /dev/null
@@ -1,35 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-
-void ML_ADM_RegisterVars(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  CCTK_INT ierr = 0;
-  
-  /* Register all the evolved grid functions with MoL */
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::K11"),  CCTK_VarIndex("ML_ADM::K11rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::K21"),  CCTK_VarIndex("ML_ADM::K21rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::K31"),  CCTK_VarIndex("ML_ADM::K31rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::K22"),  CCTK_VarIndex("ML_ADM::K22rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::K32"),  CCTK_VarIndex("ML_ADM::K32rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::K33"),  CCTK_VarIndex("ML_ADM::K33rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::alpha"),  CCTK_VarIndex("ML_ADM::alpharhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::g11"),  CCTK_VarIndex("ML_ADM::g11rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::g21"),  CCTK_VarIndex("ML_ADM::g21rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::g31"),  CCTK_VarIndex("ML_ADM::g31rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::g22"),  CCTK_VarIndex("ML_ADM::g22rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::g32"),  CCTK_VarIndex("ML_ADM::g32rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::g33"),  CCTK_VarIndex("ML_ADM::g33rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::beta1"),  CCTK_VarIndex("ML_ADM::beta1rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::beta2"),  CCTK_VarIndex("ML_ADM::beta2rhs"));
-  ierr += MoLRegisterEvolved(CCTK_VarIndex("ML_ADM::beta3"),  CCTK_VarIndex("ML_ADM::beta3rhs"));
-  return;
-}
diff --git a/m/ML_ADM/src/RegisterSymmetries.c b/m/ML_ADM/src/RegisterSymmetries.c
deleted file mode 100644
index 9a2e722..0000000
--- a/m/ML_ADM/src/RegisterSymmetries.c
+++ /dev/null
@@ -1,122 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "Symmetry.h"
-
-void ML_ADM_RegisterSymmetries(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* array holding symmetry definitions */
-  CCTK_INT sym[3];
-  
-  
-  /* Register symmetries of grid functions */
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K11");
-  
-  sym[0] = -1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K21");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K31");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K22");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K32");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::K33");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::alpha");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g11");
-  
-  sym[0] = -1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g21");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g31");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g22");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g32");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::g33");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::beta1");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::beta2");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::beta3");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::H");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::M1");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::M2");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_ADM::M3");
-  
-}
diff --git a/m/ML_ADM/src/Startup.c b/m/ML_ADM/src/Startup.c
deleted file mode 100644
index 136b76f..0000000
--- a/m/ML_ADM/src/Startup.c
+++ /dev/null
@@ -1,13 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#include "cctk.h"
-
-int ML_ADM_Startup(void)
-{
-  const char * banner = "ML_ADM";
-  CCTK_RegisterBanner(banner);
-  return 0;
-}
diff --git a/m/ML_ADM/src/make.code.defn b/m/ML_ADM/src/make.code.defn
deleted file mode 100644
index 6e2a3f8..0000000
--- a/m/ML_ADM/src/make.code.defn
+++ /dev/null
@@ -1,6 +0,0 @@
-# File produced by user eschnett
-# Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007)
-
-# Mathematica script written by Ian Hinder and Sascha Husa
-
-SRCS = Startup.c RegisterMoL.c RegisterSymmetries.c ML_ADM_Minkowski.c ML_ADM_convertFromADMBase.c ML_ADM_RHS.c ML_ADM_convertToADMBase.c ML_ADM_constraints.c Boundaries.c 
diff --git a/m/ML_BSSN/configuration.ccl b/m/ML_BSSN/configuration.ccl
deleted file mode 100644
index 0374af4..0000000
--- a/m/ML_BSSN/configuration.ccl
+++ /dev/null
@@ -1,6 +0,0 @@
-# File produced by user eschnett
-# Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007)
-
-# Mathematica script written by Ian Hinder and Sascha Husa
-
-REQUIRES LoopControl
diff --git a/m/ML_BSSN/interface.ccl b/m/ML_BSSN/interface.ccl
deleted file mode 100644
index d68366c..0000000
--- a/m/ML_BSSN/interface.ccl
+++ /dev/null
@@ -1,135 +0,0 @@
-# File produced by user eschnett
-# Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007)
-
-# Mathematica script written by Ian Hinder and Sascha Husa
-
-implements: ML_BSSN
-
-inherits:   ADMBase Grid GenericFD Boundary
-
-
-
-USES INCLUDE: GenericFD.h
-USES INCLUDE: Symmetry.h
-USES INCLUDE: sbp_calc_coeffs.h
-USES INCLUDE: Boundary.h
-USES INCLUDE: loopcontrol.h
-
-CCTK_INT FUNCTION MoLRegisterEvolved(CCTK_INT IN EvolvedIndex, CCTK_INT IN RHSIndex)
-USES FUNCTION MoLRegisterEvolved
-
-CCTK_INT FUNCTION MoLRegisterConstrained(CCTK_INT IN ConstrainedIndex)
-USES FUNCTION MoLRegisterConstrained
-
-SUBROUTINE Diff_coeff(CCTK_POINTER_TO_CONST IN cctkGH, CCTK_INT IN dir, CCTK_INT IN nsize, CCTK_INT OUT ARRAY imin, CCTK_INT OUT ARRAY imax, CCTK_REAL OUT ARRAY q, CCTK_INT IN table_handle)
-USES FUNCTION Diff_coeff
-
-CCTK_INT FUNCTION Boundary_SelectGroupForBC(CCTK_POINTER_TO_CONST IN GH, CCTK_INT IN faces, CCTK_INT IN boundary_width, CCTK_INT IN table_handle, CCTK_STRING IN group_name, CCTK_STRING IN bc_name)
-USES FUNCTION Boundary_SelectGroupForBC
-
-CCTK_INT FUNCTION Boundary_SelectVarForBC(CCTK_POINTER_TO_CONST IN GH, CCTK_INT IN faces, CCTK_INT IN boundary_width, CCTK_INT IN table_handle, CCTK_STRING IN var_name, CCTK_STRING IN bc_name)
-USES FUNCTION Boundary_SelectVarForBC
-
-public:
-CCTK_REAL cons_detg type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  cS
-} "cons_detg"
-
-public:
-CCTK_REAL cons_Gamma type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
-{
-  cXt1,
-  cXt2,
-  cXt3
-} "cons_Gamma"
-
-public:
-CCTK_REAL cons_traceA type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  cA
-} "cons_traceA"
-
-public:
-CCTK_REAL curv type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
-{
-  At11,
-  At21,
-  At31,
-  At22,
-  At32,
-  At33
-} "curv"
-
-public:
-CCTK_REAL dtlapse type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  dtalpha
-} "dtlapse"
-
-public:
-CCTK_REAL dtshift type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
-{
-  dtbeta1,
-  dtbeta2,
-  dtbeta3
-} "dtshift"
-
-public:
-CCTK_REAL Gamma type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
-{
-  Xt1,
-  Xt2,
-  Xt3
-} "Gamma"
-
-public:
-CCTK_REAL Ham type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  H
-} "Ham"
-
-public:
-CCTK_REAL lapse type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  alpha
-} "lapse"
-
-public:
-CCTK_REAL log_confac type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  phi
-} "log_confac"
-
-public:
-CCTK_REAL metric type=GF timelevels=1 tags='tensortypealias="DD_sym" tensorweight=1.0000000000000000000'
-{
-  gt11,
-  gt21,
-  gt31,
-  gt22,
-  gt32,
-  gt33
-} "metric"
-
-public:
-CCTK_REAL mom type=GF timelevels=1 tags='tensortypealias="D" tensorweight=1.0000000000000000000'
-{
-  M1,
-  M2,
-  M3
-} "mom"
-
-public:
-CCTK_REAL shift type=GF timelevels=1 tags='tensortypealias="U" tensorweight=1.0000000000000000000'
-{
-  beta1,
-  beta2,
-  beta3
-} "shift"
-
-public:
-CCTK_REAL trace_curv type=GF timelevels=1 tags='tensortypealias="Scalar" tensorweight=1.0000000000000000000'
-{
-  trK
-} "trace_curv"
diff --git a/m/ML_BSSN/param.ccl b/m/ML_BSSN/param.ccl
deleted file mode 100644
index 58a43b8..0000000
--- a/m/ML_BSSN/param.ccl
+++ /dev/null
@@ -1,122 +0,0 @@
-# File produced by user eschnett
-# Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007)
-
-# Mathematica script written by Ian Hinder and Sascha Husa
-
-
-shares: ADMBase
-
-USES CCTK_KEYWORD initial_data
-
-
-shares: GenericFD
-
-USES CCTK_INT stencil_width
-USES CCTK_INT stencil_width_x
-USES CCTK_INT stencil_width_y
-USES CCTK_INT stencil_width_z
-USES CCTK_INT boundary_width
-
-
-shares: MethodOfLines
-
-USES CCTK_INT MoL_Num_Evolved_Vars
-USES CCTK_INT MoL_Num_Constrained_Vars
-
-restricted:
-CCTK_REAL verbose "verbose"
-{
-  "*:*" :: "no restrictions"
-} 0
-
-private:
-KEYWORD my_initial_data "my_initial_data"
-{
-  "ADMBase" :: "ADMBase"
-  "Minkowski" :: "Minkowski"
-} "ADMBase"
-
-restricted:
-CCTK_INT ML_BSSN_MaxNumEvolvedVars "Number of evolved variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_Evolved_Vars
-{
-  0:0 :: "Number of evolved variables used by this thorn"
-} 0
-
-restricted:
-CCTK_INT ML_BSSN_MaxNumConstrainedVars "Number of constrained variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_Constrained_Vars
-{
-  58:58 :: "Number of constrained variables used by this thorn"
-} 58
-
-restricted:
-CCTK_INT ML_BSSN_Minkowski_calc_every "ML_BSSN_Minkowski_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_BSSN_convertFromADMBase_calc_every "ML_BSSN_convertFromADMBase_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_BSSN_convertFromADMBaseGamma_calc_every "ML_BSSN_convertFromADMBaseGamma_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_BSSN_enforce_calc_every "ML_BSSN_enforce_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_BSSN_convertToADMBase_calc_every "ML_BSSN_convertToADMBase_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_BSSN_constraints_calc_every "ML_BSSN_constraints_calc_every"
-{
-  *:* :: "no restrictions"
-} 1
-
-restricted:
-CCTK_INT ML_BSSN_Minkowski_calc_offset "ML_BSSN_Minkowski_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
-restricted:
-CCTK_INT ML_BSSN_convertFromADMBase_calc_offset "ML_BSSN_convertFromADMBase_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
-restricted:
-CCTK_INT ML_BSSN_convertFromADMBaseGamma_calc_offset "ML_BSSN_convertFromADMBaseGamma_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
-restricted:
-CCTK_INT ML_BSSN_enforce_calc_offset "ML_BSSN_enforce_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
-restricted:
-CCTK_INT ML_BSSN_convertToADMBase_calc_offset "ML_BSSN_convertToADMBase_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
-restricted:
-CCTK_INT ML_BSSN_constraints_calc_offset "ML_BSSN_constraints_calc_offset"
-{
-  *:* :: "no restrictions"
-} 0
-
diff --git a/m/ML_BSSN/schedule.ccl b/m/ML_BSSN/schedule.ccl
deleted file mode 100644
index 98438ed..0000000
--- a/m/ML_BSSN/schedule.ccl
+++ /dev/null
@@ -1,150 +0,0 @@
-# File produced by user eschnett
-# Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007)
-
-# Mathematica script written by Ian Hinder and Sascha Husa
-
-
-STORAGE: cons_detg[1]
-
-STORAGE: cons_Gamma[1]
-
-STORAGE: cons_traceA[1]
-
-STORAGE: curv[1]
-
-STORAGE: dtlapse[1]
-
-STORAGE: dtshift[1]
-
-STORAGE: Gamma[1]
-
-STORAGE: Ham[1]
-
-STORAGE: lapse[1]
-
-STORAGE: log_confac[1]
-
-STORAGE: metric[1]
-
-STORAGE: mom[1]
-
-STORAGE: shift[1]
-
-STORAGE: trace_curv[1]
-
-schedule ML_BSSN_Startup at STARTUP
-{
-  LANG: C
-  OPTIONS: meta
-} "create banner"
-
-schedule ML_BSSN_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
-schedule ML_BSSN_RegisterSymmetries at BASEGRID
-{
-  LANG: C
-  OPTIONS: meta
-} "register symmetries"
-
-
-if (CCTK_EQUALS(my_initial_data, "Minkowski"))
-{
-  schedule ML_BSSN_Minkowski IN ADMBase_InitialData
-  {
-    LANG: C
-    
-  } "ML_BSSN_Minkowski"
-}
-
-
-if (CCTK_EQUALS(my_initial_data, "ADMBase"))
-{
-  schedule ML_BSSN_convertFromADMBase AT initial
-  {
-    LANG: C
-    
-  } "ML_BSSN_convertFromADMBase"
-}
-
-
-if (CCTK_EQUALS(my_initial_data, "ADMBase"))
-{
-  schedule ML_BSSN_convertFromADMBase AFTER ADMBase_PostInitial
-  {
-    LANG: C
-    
-  } "ML_BSSN_convertFromADMBase"
-}
-
-
-if (CCTK_EQUALS(my_initial_data, "ADMBase"))
-{
-  schedule ML_BSSN_convertFromADMBaseGamma AT initial
-  {
-    LANG: C
-    
-    SYNC: Gamma
-  } "ML_BSSN_convertFromADMBaseGamma"
-}
-
-
-if (CCTK_EQUALS(my_initial_data, "ADMBase"))
-{
-  schedule ML_BSSN_convertFromADMBaseGamma AFTER ML_BSSN_convertFromADMBase
-  {
-    LANG: C
-    
-    SYNC: Gamma
-  } "ML_BSSN_convertFromADMBaseGamma"
-}
-
-schedule ML_BSSN_enforce IN MoL_PostStep
-{
-  LANG: C
-  
-} "ML_BSSN_enforce"
-
-schedule ML_BSSN_convertToADMBase IN MoL_PostStep
-{
-  LANG: C
-  
-} "ML_BSSN_convertToADMBase"
-
-schedule ML_BSSN_convertToADMBase AFTER ML_ADM_ApplyBoundConds
-{
-  LANG: C
-  
-} "ML_BSSN_convertToADMBase"
-
-schedule ML_BSSN_constraints AT analysis
-{
-  LANG: C
-  
-  SYNC: cons_detg
-  SYNC: cons_Gamma
-  SYNC: cons_traceA
-  SYNC: Ham
-  SYNC: mom
-} "ML_BSSN_constraints"
-
-schedule ML_BSSN_ApplyBoundConds in MoL_PostStep
-{
-  LANG: C
-  OPTIONS: level
-} "apply boundary conditions"
-
-schedule ML_BSSN_CheckBoundaries at BASEGRID
-{
-  LANG: C
-  OPTIONS: meta
-} "check boundaries treatment"
-
-schedule group ApplyBCs as ML_BSSN_ApplyBCs in MoL_PostStep  after ML_BSSN_ApplyBoundConds
-{
-  # no language specified
-  
-} "Apply boundary conditions controlled by thorn Boundary"
diff --git a/m/ML_BSSN/src/Boundaries.c b/m/ML_BSSN/src/Boundaries.c
deleted file mode 100644
index cd2f9aa..0000000
--- a/m/ML_BSSN/src/Boundaries.c
+++ /dev/null
@@ -1,44 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "cctk_Faces.h"
-#include "util_Table.h"
-#include "Symmetry.h"
-
-
-/* the boundary treatment is split into 3 steps:    */
-/* 1. excision                                      */
-/* 2. symmetries                                    */
-/* 3. "other" boundary conditions, e.g. radiative */
-
-/* to simplify scheduling and testing, the 3 steps  */
-/* are currently applied in separate functions      */
-
-
-void ML_BSSN_CheckBoundaries(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  return;
-}
-
-void ML_BSSN_ApplyBoundConds(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  CCTK_INT ierr = 0;
-  return;
-}
-
-
-
-/* template for entries in parameter file:
-*/
-
diff --git a/m/ML_BSSN/src/Differencing.h b/m/ML_BSSN/src/Differencing.h
deleted file mode 100644
index 7ada6a7..0000000
--- a/m/ML_BSSN/src/Differencing.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#define PDstandard4th1(u,i,j,k) (p1o12dx*(-8*u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,k)] + 8*u[CCTK_GFINDEX3D(cctkGH,1 + i,j,k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,k)] - u[CCTK_GFINDEX3D(cctkGH,2 + i,j,k)]))
-#define PDstandard4th2(u,i,j,k) (p1o12dy*(-8*u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,k)] + 8*u[CCTK_GFINDEX3D(cctkGH,i,1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,k)] - u[CCTK_GFINDEX3D(cctkGH,i,2 + j,k)]))
-#define PDstandard4th3(u,i,j,k) (p1o12dz*(-8*u[CCTK_GFINDEX3D(cctkGH,i,j,-1 + k)] + 8*u[CCTK_GFINDEX3D(cctkGH,i,j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,j,-2 + k)] - u[CCTK_GFINDEX3D(cctkGH,i,j,2 + k)]))
-#define PDstandard4th11(u,i,j,k) (pm1o12dx2*(-16*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,k)]) + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,k)] + 30*u[CCTK_GFINDEX3D(cctkGH,i,j,k)]))
-#define PDstandard4th22(u,i,j,k) (pm1o12dy2*(-16*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,k)]) + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,k)] + 30*u[CCTK_GFINDEX3D(cctkGH,i,j,k)]))
-#define PDstandard4th33(u,i,j,k) (pm1o12dz2*(-16*(u[CCTK_GFINDEX3D(cctkGH,i,j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,j,1 + k)]) + u[CCTK_GFINDEX3D(cctkGH,i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,j,2 + k)] + 30*u[CCTK_GFINDEX3D(cctkGH,i,j,k)]))
-#define PDstandard4th12(u,i,j,k) (p1o144dxdy*(-64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,-1 + j,k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,-1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,1 + j,k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,-1 + j,k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,-1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,1 + j,k)]) + u[CCTK_GFINDEX3D(cctkGH,-2 + i,-2 + j,k)] - u[CCTK_GFINDEX3D(cctkGH,-2 + i,2 + j,k)] - u[CCTK_GFINDEX3D(cctkGH,2 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,2 + j,k)]))
-#define PDstandard4th13(u,i,j,k) (p1o144dxdz*(-64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,-1 + k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,1 + k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,-1 + k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,1 + k)]) + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,-2 + k)] - u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,2 + k)] - u[CCTK_GFINDEX3D(cctkGH,2 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,2 + k)]))
-#define PDstandard4th21(u,i,j,k) (p1o144dxdy*(-64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,-1 + j,k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,-1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,1 + j,k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,-1 + j,k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,-1 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,1 + j,k)]) + u[CCTK_GFINDEX3D(cctkGH,-2 + i,-2 + j,k)] - u[CCTK_GFINDEX3D(cctkGH,-2 + i,2 + j,k)] - u[CCTK_GFINDEX3D(cctkGH,2 + i,-2 + j,k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,2 + j,k)]))
-#define PDstandard4th23(u,i,j,k) (p1o144dydz*(-64*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,-1 + k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,1 + k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,-1 + k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,1 + k)]) + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,-2 + k)] - u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,2 + k)] - u[CCTK_GFINDEX3D(cctkGH,i,2 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,2 + k)]))
-#define PDstandard4th31(u,i,j,k) (p1o144dxdz*(-64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,-1 + k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,1 + k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,-1 + k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,-1 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,1 + i,j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,1 + k)]) + u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,-2 + k)] - u[CCTK_GFINDEX3D(cctkGH,-2 + i,j,2 + k)] - u[CCTK_GFINDEX3D(cctkGH,2 + i,j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,2 + i,j,2 + k)]))
-#define PDstandard4th32(u,i,j,k) (p1o144dydz*(-64*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,-1 + k)]) + 64*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,1 + k)]) + 8*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,-1 + k)]) - 8*(u[CCTK_GFINDEX3D(cctkGH,i,-1 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,1 + j,2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,-1 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,1 + k)]) + u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,-2 + k)] - u[CCTK_GFINDEX3D(cctkGH,i,-2 + j,2 + k)] - u[CCTK_GFINDEX3D(cctkGH,i,2 + j,-2 + k)] + u[CCTK_GFINDEX3D(cctkGH,i,2 + j,2 + k)]))
diff --git a/m/ML_BSSN/src/ML_BSSN_Minkowski.c b/m/ML_BSSN/src/ML_BSSN_Minkowski.c
deleted file mode 100644
index 698abe5..0000000
--- a/m/ML_BSSN/src/ML_BSSN_Minkowski.c
+++ /dev/null
@@ -1,212 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_BSSN_Minkowski_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_BSSN_Minkowski_Body");
-  }
-  
-  if (cctk_iteration % ML_BSSN_Minkowski_calc_every != ML_BSSN_Minkowski_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL alphaL = INITVALUE;
-    CCTK_REAL At11L = INITVALUE, At21L = INITVALUE, At22L = INITVALUE, At31L = INITVALUE, At32L = INITVALUE, At33L = INITVALUE;
-    CCTK_REAL beta1L = INITVALUE, beta2L = INITVALUE, beta3L = INITVALUE;
-    CCTK_REAL dtalphaL = INITVALUE;
-    CCTK_REAL dtbeta1L = INITVALUE, dtbeta2L = INITVALUE, dtbeta3L = INITVALUE;
-    CCTK_REAL gt11L = INITVALUE, gt21L = INITVALUE, gt22L = INITVALUE, gt31L = INITVALUE, gt32L = INITVALUE, gt33L = INITVALUE;
-    CCTK_REAL phiL = INITVALUE;
-    CCTK_REAL trKL = INITVALUE;
-    CCTK_REAL Xt1L = INITVALUE, Xt2L = INITVALUE, Xt3L = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    
-    /* Assign local copies of grid functions */
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    phiL  =  0;
-    
-    gt11L  =  1;
-    
-    gt21L  =  0;
-    
-    gt31L  =  0;
-    
-    gt22L  =  1;
-    
-    gt32L  =  0;
-    
-    gt33L  =  1;
-    
-    trKL  =  0;
-    
-    At11L  =  0;
-    
-    At21L  =  0;
-    
-    At31L  =  0;
-    
-    At22L  =  0;
-    
-    At32L  =  0;
-    
-    At33L  =  0;
-    
-    Xt1L  =  0;
-    
-    Xt2L  =  0;
-    
-    Xt3L  =  0;
-    
-    alphaL  =  1;
-    
-    dtalphaL  =  0;
-    
-    beta1L  =  0;
-    
-    beta2L  =  0;
-    
-    beta3L  =  0;
-    
-    dtbeta1L  =  0;
-    
-    dtbeta2L  =  0;
-    
-    dtbeta3L  =  0;
-    
-    
-    /* Copy local copies back to grid functions */
-    alpha[index] = alphaL;
-    At11[index] = At11L;
-    At21[index] = At21L;
-    At22[index] = At22L;
-    At31[index] = At31L;
-    At32[index] = At32L;
-    At33[index] = At33L;
-    beta1[index] = beta1L;
-    beta2[index] = beta2L;
-    beta3[index] = beta3L;
-    dtalpha[index] = dtalphaL;
-    dtbeta1[index] = dtbeta1L;
-    dtbeta2[index] = dtbeta2L;
-    dtbeta3[index] = dtbeta3L;
-    gt11[index] = gt11L;
-    gt21[index] = gt21L;
-    gt22[index] = gt22L;
-    gt31[index] = gt31L;
-    gt32[index] = gt32L;
-    gt33[index] = gt33L;
-    phi[index] = phiL;
-    trK[index] = trKL;
-    Xt1[index] = Xt1L;
-    Xt2[index] = Xt2L;
-    Xt3[index] = Xt3L;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_BSSN_Minkowski(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverEverything(cctkGH, &ML_BSSN_Minkowski_Body);
-}
diff --git a/m/ML_BSSN/src/ML_BSSN_constraints.c b/m/ML_BSSN/src/ML_BSSN_constraints.c
deleted file mode 100644
index 454745d..0000000
--- a/m/ML_BSSN/src/ML_BSSN_constraints.c
+++ /dev/null
@@ -1,980 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_BSSN_constraints_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_BSSN_constraints_Body");
-  }
-  
-  if (cctk_iteration % ML_BSSN_constraints_calc_every != ML_BSSN_constraints_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    CCTK_REAL ddetg1 = INITVALUE, ddetg2 = INITVALUE, ddetg3 = INITVALUE;
-    CCTK_REAL ddetgt1 = INITVALUE, ddetgt2 = INITVALUE, ddetgt3 = INITVALUE;
-    CCTK_REAL detg = INITVALUE;
-    CCTK_REAL detgt = INITVALUE;
-    CCTK_REAL e4phi = INITVALUE;
-    CCTK_REAL g11 = INITVALUE;
-    CCTK_REAL G111 = INITVALUE, G121 = INITVALUE, G122 = INITVALUE, G131 = INITVALUE, G132 = INITVALUE, G133 = INITVALUE;
-    CCTK_REAL g21 = INITVALUE;
-    CCTK_REAL G211 = INITVALUE;
-    CCTK_REAL g22 = INITVALUE;
-    CCTK_REAL G221 = INITVALUE, G222 = INITVALUE, G231 = INITVALUE, G232 = INITVALUE, G233 = INITVALUE;
-    CCTK_REAL g31 = INITVALUE;
-    CCTK_REAL G311 = INITVALUE;
-    CCTK_REAL g32 = INITVALUE;
-    CCTK_REAL G321 = INITVALUE, G322 = INITVALUE;
-    CCTK_REAL g33 = INITVALUE;
-    CCTK_REAL G331 = INITVALUE, G332 = INITVALUE, G333 = INITVALUE;
-    CCTK_REAL gK112 = INITVALUE, gK113 = INITVALUE, gK211 = INITVALUE, gK212 = INITVALUE, gK213 = INITVALUE, gK221 = INITVALUE;
-    CCTK_REAL gK223 = INITVALUE, gK311 = INITVALUE, gK312 = INITVALUE, gK313 = INITVALUE, gK321 = INITVALUE, gK322 = INITVALUE;
-    CCTK_REAL gK323 = INITVALUE, gK331 = INITVALUE, gK332 = INITVALUE;
-    CCTK_REAL Gt111 = INITVALUE, Gt121 = INITVALUE, Gt122 = INITVALUE, Gt131 = INITVALUE, Gt132 = INITVALUE, Gt133 = INITVALUE;
-    CCTK_REAL Gt211 = INITVALUE, Gt221 = INITVALUE, Gt222 = INITVALUE, Gt231 = INITVALUE, Gt232 = INITVALUE, Gt233 = INITVALUE;
-    CCTK_REAL Gt311 = INITVALUE, Gt321 = INITVALUE, Gt322 = INITVALUE, Gt331 = INITVALUE, Gt332 = INITVALUE, Gt333 = INITVALUE;
-    CCTK_REAL gtu11 = INITVALUE, gtu12 = INITVALUE, gtu13 = INITVALUE, gtu22 = INITVALUE, gtu23 = INITVALUE, gtu33 = INITVALUE;
-    CCTK_REAL gu11 = INITVALUE, gu12 = INITVALUE, gu13 = INITVALUE, gu22 = INITVALUE, gu23 = INITVALUE, gu33 = INITVALUE;
-    CCTK_REAL K11 = INITVALUE, K21 = INITVALUE, K22 = INITVALUE, K31 = INITVALUE, K32 = INITVALUE, K33 = INITVALUE;
-    CCTK_REAL Km11 = INITVALUE, Km12 = INITVALUE, Km13 = INITVALUE, Km21 = INITVALUE, Km22 = INITVALUE, Km23 = INITVALUE;
-    CCTK_REAL Km31 = INITVALUE, Km32 = INITVALUE, Km33 = INITVALUE;
-    CCTK_REAL R11 = INITVALUE, R21 = INITVALUE, R22 = INITVALUE, R31 = INITVALUE, R32 = INITVALUE, R33 = INITVALUE;
-    CCTK_REAL Rphi11 = INITVALUE, Rphi21 = INITVALUE, Rphi22 = INITVALUE, Rphi31 = INITVALUE, Rphi32 = INITVALUE, Rphi33 = INITVALUE;
-    CCTK_REAL Rt11 = INITVALUE, Rt21 = INITVALUE, Rt22 = INITVALUE, Rt31 = INITVALUE, Rt32 = INITVALUE, Rt33 = INITVALUE;
-    CCTK_REAL trR = INITVALUE;
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL At11L = INITVALUE, At21L = INITVALUE, At22L = INITVALUE, At31L = INITVALUE, At32L = INITVALUE, At33L = INITVALUE;
-    CCTK_REAL cAL = INITVALUE;
-    CCTK_REAL cSL = INITVALUE;
-    CCTK_REAL cXt1L = INITVALUE, cXt2L = INITVALUE, cXt3L = INITVALUE;
-    CCTK_REAL gt11L = INITVALUE, gt21L = INITVALUE, gt22L = INITVALUE, gt31L = INITVALUE, gt32L = INITVALUE, gt33L = INITVALUE;
-    CCTK_REAL HL = INITVALUE;
-    CCTK_REAL M1L = INITVALUE, M2L = INITVALUE, M3L = INITVALUE;
-    CCTK_REAL phiL = INITVALUE;
-    CCTK_REAL trKL = INITVALUE;
-    CCTK_REAL Xt1L = INITVALUE, Xt2L = INITVALUE, Xt3L = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    CCTK_REAL PDstandard4th2At11 = INITVALUE;
-    CCTK_REAL PDstandard4th3At11 = INITVALUE;
-    CCTK_REAL PDstandard4th1At21 = INITVALUE;
-    CCTK_REAL PDstandard4th2At21 = INITVALUE;
-    CCTK_REAL PDstandard4th3At21 = INITVALUE;
-    CCTK_REAL PDstandard4th1At22 = INITVALUE;
-    CCTK_REAL PDstandard4th3At22 = INITVALUE;
-    CCTK_REAL PDstandard4th1At31 = INITVALUE;
-    CCTK_REAL PDstandard4th2At31 = INITVALUE;
-    CCTK_REAL PDstandard4th3At31 = INITVALUE;
-    CCTK_REAL PDstandard4th1At32 = INITVALUE;
-    CCTK_REAL PDstandard4th2At32 = INITVALUE;
-    CCTK_REAL PDstandard4th3At32 = INITVALUE;
-    CCTK_REAL PDstandard4th1At33 = INITVALUE;
-    CCTK_REAL PDstandard4th2At33 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th11gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th22gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th33gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th12gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th13gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th21gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th23gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th31gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th32gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th11gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th22gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th33gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th12gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th13gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th21gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th23gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th31gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th32gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th11gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th22gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th33gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th12gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th13gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th21gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th23gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th31gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th32gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th11gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th22gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th33gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th12gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th13gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th21gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th23gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th31gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th32gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th11gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th22gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th33gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th12gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th13gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th21gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th23gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th31gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th32gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th11gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th22gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th33gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th12gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th13gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th21gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th23gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th31gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th32gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th1phi = INITVALUE;
-    CCTK_REAL PDstandard4th2phi = INITVALUE;
-    CCTK_REAL PDstandard4th3phi = INITVALUE;
-    CCTK_REAL PDstandard4th11phi = INITVALUE;
-    CCTK_REAL PDstandard4th22phi = INITVALUE;
-    CCTK_REAL PDstandard4th33phi = INITVALUE;
-    CCTK_REAL PDstandard4th12phi = INITVALUE;
-    CCTK_REAL PDstandard4th13phi = INITVALUE;
-    CCTK_REAL PDstandard4th21phi = INITVALUE;
-    CCTK_REAL PDstandard4th23phi = INITVALUE;
-    CCTK_REAL PDstandard4th31phi = INITVALUE;
-    CCTK_REAL PDstandard4th32phi = INITVALUE;
-    CCTK_REAL PDstandard4th1trK = INITVALUE;
-    CCTK_REAL PDstandard4th2trK = INITVALUE;
-    CCTK_REAL PDstandard4th3trK = INITVALUE;
-    CCTK_REAL PDstandard4th1Xt1 = INITVALUE;
-    CCTK_REAL PDstandard4th2Xt1 = INITVALUE;
-    CCTK_REAL PDstandard4th3Xt1 = INITVALUE;
-    CCTK_REAL PDstandard4th1Xt2 = INITVALUE;
-    CCTK_REAL PDstandard4th2Xt2 = INITVALUE;
-    CCTK_REAL PDstandard4th3Xt2 = INITVALUE;
-    CCTK_REAL PDstandard4th1Xt3 = INITVALUE;
-    CCTK_REAL PDstandard4th2Xt3 = INITVALUE;
-    CCTK_REAL PDstandard4th3Xt3 = INITVALUE;
-    
-    /* Assign local copies of grid functions */
-    At11L = At11[index];
-    At21L = At21[index];
-    At22L = At22[index];
-    At31L = At31[index];
-    At32L = At32[index];
-    At33L = At33[index];
-    gt11L = gt11[index];
-    gt21L = gt21[index];
-    gt22L = gt22[index];
-    gt31L = gt31[index];
-    gt32L = gt32[index];
-    gt33L = gt33[index];
-    phiL = phi[index];
-    trKL = trK[index];
-    Xt1L = Xt1[index];
-    Xt2L = Xt2[index];
-    Xt3L = Xt3[index];
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    PDstandard4th2At11 = PDstandard4th2(At11, i, j, k);
-    PDstandard4th3At11 = PDstandard4th3(At11, i, j, k);
-    PDstandard4th1At21 = PDstandard4th1(At21, i, j, k);
-    PDstandard4th2At21 = PDstandard4th2(At21, i, j, k);
-    PDstandard4th3At21 = PDstandard4th3(At21, i, j, k);
-    PDstandard4th1At22 = PDstandard4th1(At22, i, j, k);
-    PDstandard4th3At22 = PDstandard4th3(At22, i, j, k);
-    PDstandard4th1At31 = PDstandard4th1(At31, i, j, k);
-    PDstandard4th2At31 = PDstandard4th2(At31, i, j, k);
-    PDstandard4th3At31 = PDstandard4th3(At31, i, j, k);
-    PDstandard4th1At32 = PDstandard4th1(At32, i, j, k);
-    PDstandard4th2At32 = PDstandard4th2(At32, i, j, k);
-    PDstandard4th3At32 = PDstandard4th3(At32, i, j, k);
-    PDstandard4th1At33 = PDstandard4th1(At33, i, j, k);
-    PDstandard4th2At33 = PDstandard4th2(At33, i, j, k);
-    PDstandard4th1gt11 = PDstandard4th1(gt11, i, j, k);
-    PDstandard4th2gt11 = PDstandard4th2(gt11, i, j, k);
-    PDstandard4th3gt11 = PDstandard4th3(gt11, i, j, k);
-    PDstandard4th11gt11 = PDstandard4th11(gt11, i, j, k);
-    PDstandard4th22gt11 = PDstandard4th22(gt11, i, j, k);
-    PDstandard4th33gt11 = PDstandard4th33(gt11, i, j, k);
-    PDstandard4th12gt11 = PDstandard4th12(gt11, i, j, k);
-    PDstandard4th13gt11 = PDstandard4th13(gt11, i, j, k);
-    PDstandard4th23gt11 = PDstandard4th23(gt11, i, j, k);
-    PDstandard4th1gt21 = PDstandard4th1(gt21, i, j, k);
-    PDstandard4th2gt21 = PDstandard4th2(gt21, i, j, k);
-    PDstandard4th3gt21 = PDstandard4th3(gt21, i, j, k);
-    PDstandard4th11gt21 = PDstandard4th11(gt21, i, j, k);
-    PDstandard4th22gt21 = PDstandard4th22(gt21, i, j, k);
-    PDstandard4th33gt21 = PDstandard4th33(gt21, i, j, k);
-    PDstandard4th12gt21 = PDstandard4th12(gt21, i, j, k);
-    PDstandard4th13gt21 = PDstandard4th13(gt21, i, j, k);
-    PDstandard4th23gt21 = PDstandard4th23(gt21, i, j, k);
-    PDstandard4th1gt22 = PDstandard4th1(gt22, i, j, k);
-    PDstandard4th2gt22 = PDstandard4th2(gt22, i, j, k);
-    PDstandard4th3gt22 = PDstandard4th3(gt22, i, j, k);
-    PDstandard4th11gt22 = PDstandard4th11(gt22, i, j, k);
-    PDstandard4th22gt22 = PDstandard4th22(gt22, i, j, k);
-    PDstandard4th33gt22 = PDstandard4th33(gt22, i, j, k);
-    PDstandard4th12gt22 = PDstandard4th12(gt22, i, j, k);
-    PDstandard4th13gt22 = PDstandard4th13(gt22, i, j, k);
-    PDstandard4th23gt22 = PDstandard4th23(gt22, i, j, k);
-    PDstandard4th1gt31 = PDstandard4th1(gt31, i, j, k);
-    PDstandard4th2gt31 = PDstandard4th2(gt31, i, j, k);
-    PDstandard4th3gt31 = PDstandard4th3(gt31, i, j, k);
-    PDstandard4th11gt31 = PDstandard4th11(gt31, i, j, k);
-    PDstandard4th22gt31 = PDstandard4th22(gt31, i, j, k);
-    PDstandard4th33gt31 = PDstandard4th33(gt31, i, j, k);
-    PDstandard4th12gt31 = PDstandard4th12(gt31, i, j, k);
-    PDstandard4th13gt31 = PDstandard4th13(gt31, i, j, k);
-    PDstandard4th23gt31 = PDstandard4th23(gt31, i, j, k);
-    PDstandard4th1gt32 = PDstandard4th1(gt32, i, j, k);
-    PDstandard4th2gt32 = PDstandard4th2(gt32, i, j, k);
-    PDstandard4th3gt32 = PDstandard4th3(gt32, i, j, k);
-    PDstandard4th11gt32 = PDstandard4th11(gt32, i, j, k);
-    PDstandard4th22gt32 = PDstandard4th22(gt32, i, j, k);
-    PDstandard4th33gt32 = PDstandard4th33(gt32, i, j, k);
-    PDstandard4th12gt32 = PDstandard4th12(gt32, i, j, k);
-    PDstandard4th13gt32 = PDstandard4th13(gt32, i, j, k);
-    PDstandard4th23gt32 = PDstandard4th23(gt32, i, j, k);
-    PDstandard4th1gt33 = PDstandard4th1(gt33, i, j, k);
-    PDstandard4th2gt33 = PDstandard4th2(gt33, i, j, k);
-    PDstandard4th3gt33 = PDstandard4th3(gt33, i, j, k);
-    PDstandard4th11gt33 = PDstandard4th11(gt33, i, j, k);
-    PDstandard4th22gt33 = PDstandard4th22(gt33, i, j, k);
-    PDstandard4th33gt33 = PDstandard4th33(gt33, i, j, k);
-    PDstandard4th12gt33 = PDstandard4th12(gt33, i, j, k);
-    PDstandard4th13gt33 = PDstandard4th13(gt33, i, j, k);
-    PDstandard4th23gt33 = PDstandard4th23(gt33, i, j, k);
-    PDstandard4th1phi = PDstandard4th1(phi, i, j, k);
-    PDstandard4th2phi = PDstandard4th2(phi, i, j, k);
-    PDstandard4th3phi = PDstandard4th3(phi, i, j, k);
-    PDstandard4th11phi = PDstandard4th11(phi, i, j, k);
-    PDstandard4th22phi = PDstandard4th22(phi, i, j, k);
-    PDstandard4th33phi = PDstandard4th33(phi, i, j, k);
-    PDstandard4th12phi = PDstandard4th12(phi, i, j, k);
-    PDstandard4th13phi = PDstandard4th13(phi, i, j, k);
-    PDstandard4th23phi = PDstandard4th23(phi, i, j, k);
-    PDstandard4th1trK = PDstandard4th1(trK, i, j, k);
-    PDstandard4th2trK = PDstandard4th2(trK, i, j, k);
-    PDstandard4th3trK = PDstandard4th3(trK, i, j, k);
-    PDstandard4th1Xt1 = PDstandard4th1(Xt1, i, j, k);
-    PDstandard4th2Xt1 = PDstandard4th2(Xt1, i, j, k);
-    PDstandard4th3Xt1 = PDstandard4th3(Xt1, i, j, k);
-    PDstandard4th1Xt2 = PDstandard4th1(Xt2, i, j, k);
-    PDstandard4th2Xt2 = PDstandard4th2(Xt2, i, j, k);
-    PDstandard4th3Xt2 = PDstandard4th3(Xt2, i, j, k);
-    PDstandard4th1Xt3 = PDstandard4th1(Xt3, i, j, k);
-    PDstandard4th2Xt3 = PDstandard4th2(Xt3, i, j, k);
-    PDstandard4th3Xt3 = PDstandard4th3(Xt3, i, j, k);
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    detgt  =  2*gt21L*gt31L*gt32L + gt33L*(gt11L*gt22L - SQR(gt21L)) - gt22L*SQR(gt31L) - gt11L*SQR(gt32L);
-    
-    ddetgt1  =  (-2*gt22L*gt31L + 2*gt21L*gt32L)*PDstandard4th1gt31 + 
-        2*((gt31L*gt32L - gt21L*gt33L)*PDstandard4th1gt21 + (gt21L*gt31L - gt11L*gt32L)*PDstandard4th1gt32) + 
-        PDstandard4th1gt33*(gt11L*gt22L - SQR(gt21L)) + PDstandard4th1gt22*(gt11L*gt33L - SQR(gt31L)) + 
-        PDstandard4th1gt11*(gt22L*gt33L - SQR(gt32L));
-    
-    ddetgt2  =  (-2*gt22L*gt31L + 2*gt21L*gt32L)*PDstandard4th2gt31 + 
-        2*((gt31L*gt32L - gt21L*gt33L)*PDstandard4th2gt21 + (gt21L*gt31L - gt11L*gt32L)*PDstandard4th2gt32) + 
-        PDstandard4th2gt33*(gt11L*gt22L - SQR(gt21L)) + PDstandard4th2gt22*(gt11L*gt33L - SQR(gt31L)) + 
-        PDstandard4th2gt11*(gt22L*gt33L - SQR(gt32L));
-    
-    ddetgt3  =  (-2*gt22L*gt31L + 2*gt21L*gt32L)*PDstandard4th3gt31 + 
-        2*((gt31L*gt32L - gt21L*gt33L)*PDstandard4th3gt21 + (gt21L*gt31L - gt11L*gt32L)*PDstandard4th3gt32) + 
-        PDstandard4th3gt33*(gt11L*gt22L - SQR(gt21L)) + PDstandard4th3gt22*(gt11L*gt33L - SQR(gt31L)) + 
-        PDstandard4th3gt11*(gt22L*gt33L - SQR(gt32L));
-    
-    gtu11  =  INV(detgt)*(gt22L*gt33L - SQR(gt32L));
-    
-    gtu12  =  (gt31L*gt32L - gt21L*gt33L)*INV(detgt);
-    
-    gtu13  =  (-(gt22L*gt31L) + gt21L*gt32L)*INV(detgt);
-    
-    gtu22  =  INV(detgt)*(gt11L*gt33L - SQR(gt31L));
-    
-    gtu23  =  (gt21L*gt31L - gt11L*gt32L)*INV(detgt);
-    
-    gtu33  =  INV(detgt)*(gt11L*gt22L - SQR(gt21L));
-    
-    Gt111  =  khalf*(gtu11*PDstandard4th1gt11 + 2*(gtu12*PDstandard4th1gt21 + gtu13*PDstandard4th1gt31) - 
-          gtu12*PDstandard4th2gt11 - gtu13*PDstandard4th3gt11);
-    
-    Gt211  =  khalf*(gtu12*PDstandard4th1gt11 + 2*(gtu22*PDstandard4th1gt21 + gtu23*PDstandard4th1gt31) - 
-          gtu22*PDstandard4th2gt11 - gtu23*PDstandard4th3gt11);
-    
-    Gt311  =  khalf*(gtu13*PDstandard4th1gt11 + 2*(gtu23*PDstandard4th1gt21 + gtu33*PDstandard4th1gt31) - 
-          gtu23*PDstandard4th2gt11 - gtu33*PDstandard4th3gt11);
-    
-    Gt121  =  khalf*(gtu12*PDstandard4th1gt22 + gtu11*PDstandard4th2gt11 + 
-          gtu13*(PDstandard4th1gt32 + PDstandard4th2gt31 - PDstandard4th3gt21));
-    
-    Gt221  =  khalf*(gtu22*PDstandard4th1gt22 + gtu12*PDstandard4th2gt11 + 
-          gtu23*(PDstandard4th1gt32 + PDstandard4th2gt31 - PDstandard4th3gt21));
-    
-    Gt321  =  khalf*(gtu23*PDstandard4th1gt22 + gtu13*PDstandard4th2gt11 + 
-          gtu33*(PDstandard4th1gt32 + PDstandard4th2gt31 - PDstandard4th3gt21));
-    
-    Gt131  =  khalf*(gtu13*PDstandard4th1gt33 + gtu11*PDstandard4th3gt11 + 
-          gtu12*(PDstandard4th1gt32 - PDstandard4th2gt31 + PDstandard4th3gt21));
-    
-    Gt231  =  khalf*(gtu23*PDstandard4th1gt33 + gtu12*PDstandard4th3gt11 + 
-          gtu22*(PDstandard4th1gt32 - PDstandard4th2gt31 + PDstandard4th3gt21));
-    
-    Gt331  =  khalf*(gtu33*PDstandard4th1gt33 + gtu13*PDstandard4th3gt11 + 
-          gtu23*(PDstandard4th1gt32 - PDstandard4th2gt31 + PDstandard4th3gt21));
-    
-    Gt122  =  khalf*(gtu11*(-PDstandard4th1gt22 + 2*PDstandard4th2gt21) + gtu12*PDstandard4th2gt22 + 
-          gtu13*(2*PDstandard4th2gt32 - PDstandard4th3gt22));
-    
-    Gt222  =  khalf*(gtu12*(-PDstandard4th1gt22 + 2*PDstandard4th2gt21) + gtu22*PDstandard4th2gt22 + 
-          gtu23*(2*PDstandard4th2gt32 - PDstandard4th3gt22));
-    
-    Gt322  =  khalf*(gtu13*(-PDstandard4th1gt22 + 2*PDstandard4th2gt21) + gtu23*PDstandard4th2gt22 + 
-          gtu33*(2*PDstandard4th2gt32 - PDstandard4th3gt22));
-    
-    Gt132  =  khalf*(gtu13*PDstandard4th2gt33 + gtu11*(-PDstandard4th1gt32 + PDstandard4th2gt31 + PDstandard4th3gt21) + 
-          gtu12*PDstandard4th3gt22);
-    
-    Gt232  =  khalf*(gtu23*PDstandard4th2gt33 + gtu12*(-PDstandard4th1gt32 + PDstandard4th2gt31 + PDstandard4th3gt21) + 
-          gtu22*PDstandard4th3gt22);
-    
-    Gt332  =  khalf*(gtu33*PDstandard4th2gt33 + gtu13*(-PDstandard4th1gt32 + PDstandard4th2gt31 + PDstandard4th3gt21) + 
-          gtu23*PDstandard4th3gt22);
-    
-    Gt133  =  khalf*(-(gtu11*PDstandard4th1gt33) - gtu12*PDstandard4th2gt33 + 2*gtu11*PDstandard4th3gt31 + 
-          2*gtu12*PDstandard4th3gt32 + gtu13*PDstandard4th3gt33);
-    
-    Gt233  =  khalf*(-(gtu12*PDstandard4th1gt33) - gtu22*PDstandard4th2gt33 + 2*gtu12*PDstandard4th3gt31 + 
-          2*gtu22*PDstandard4th3gt32 + gtu23*PDstandard4th3gt33);
-    
-    Gt333  =  khalf*(-(gtu13*PDstandard4th1gt33) - gtu23*PDstandard4th2gt33 + 2*gtu13*PDstandard4th3gt31 + 
-          2*gtu23*PDstandard4th3gt32 + gtu33*PDstandard4th3gt33);
-    
-    e4phi  =  exp(4*phiL);
-    
-    g11  =  e4phi*gt11L;
-    
-    g21  =  e4phi*gt21L;
-    
-    g31  =  e4phi*gt31L;
-    
-    g22  =  e4phi*gt22L;
-    
-    g32  =  e4phi*gt32L;
-    
-    g33  =  e4phi*gt33L;
-    
-    detg  =  2*g21*g31*g32 + g33*(g11*g22 - SQR(g21)) - g22*SQR(g31) - g11*SQR(g32);
-    
-    gu11  =  INV(detg)*(g22*g33 - SQR(g32));
-    
-    gu12  =  (g31*g32 - g21*g33)*INV(detg);
-    
-    gu13  =  (-(g22*g31) + g21*g32)*INV(detg);
-    
-    gu22  =  INV(detg)*(g11*g33 - SQR(g31));
-    
-    gu23  =  (g21*g31 - g11*g32)*INV(detg);
-    
-    gu33  =  INV(detg)*(g11*g22 - SQR(g21));
-    
-    ddetg1  =  e4phi*(ddetgt1 + 4*detgt*PDstandard4th1phi);
-    
-    ddetg2  =  e4phi*(ddetgt2 + 4*detgt*PDstandard4th2phi);
-    
-    ddetg3  =  e4phi*(ddetgt3 + 4*detgt*PDstandard4th3phi);
-    
-    G111  =  -((-6*detg*Gt111 + ddetg1*(-6 + g11*gu11) + g11*(ddetg2*gu12 + ddetg3*gu13))*INV(detg))/6.;
-    
-    G211  =  ((6*detg*Gt211 - g11*(ddetg1*gu12 + ddetg2*gu22 + ddetg3*gu23))*INV(detg))/6.;
-    
-    G311  =  ((6*detg*Gt311 - g11*(ddetg1*gu13 + ddetg2*gu23 + ddetg3*gu33))*INV(detg))/6.;
-    
-    G121  =  -((-6*detg*Gt121 + ddetg2*(-3 + g21*gu12) + g21*(ddetg1*gu11 + ddetg3*gu13))*INV(detg))/6.;
-    
-    G221  =  -((-6*detg*Gt221 + ddetg1*(-3 + g21*gu12) + g21*(ddetg2*gu22 + ddetg3*gu23))*INV(detg))/6.;
-    
-    G321  =  ((6*detg*Gt321 - g21*(ddetg1*gu13 + ddetg2*gu23 + ddetg3*gu33))*INV(detg))/6.;
-    
-    G131  =  -((-6*detg*Gt131 + g31*(ddetg1*gu11 + ddetg2*gu12) + ddetg3*(-3 + g31*gu13))*INV(detg))/6.;
-    
-    G231  =  ((6*detg*Gt231 - g31*(ddetg1*gu12 + ddetg2*gu22 + ddetg3*gu23))*INV(detg))/6.;
-    
-    G331  =  -((-6*detg*Gt331 + ddetg1*(-3 + g31*gu13) + g31*(ddetg2*gu23 + ddetg3*gu33))*INV(detg))/6.;
-    
-    G122  =  ((6*detg*Gt122 - g22*(ddetg1*gu11 + ddetg2*gu12 + ddetg3*gu13))*INV(detg))/6.;
-    
-    G222  =  -((-6*detg*Gt222 + ddetg2*(-6 + g22*gu22) + g22*(ddetg1*gu12 + ddetg3*gu23))*INV(detg))/6.;
-    
-    G322  =  ((6*detg*Gt322 - g22*(ddetg1*gu13 + ddetg2*gu23 + ddetg3*gu33))*INV(detg))/6.;
-    
-    G132  =  ((6*detg*Gt132 - g32*(ddetg1*gu11 + ddetg2*gu12 + ddetg3*gu13))*INV(detg))/6.;
-    
-    G232  =  -((-6*detg*Gt232 + g32*(ddetg1*gu12 + ddetg2*gu22) + ddetg3*(-3 + g32*gu23))*INV(detg))/6.;
-    
-    G332  =  -((-6*detg*Gt332 + ddetg2*(-3 + g32*gu23) + g32*(ddetg1*gu13 + ddetg3*gu33))*INV(detg))/6.;
-    
-    G133  =  ((6*detg*Gt133 - g33*(ddetg1*gu11 + ddetg2*gu12 + ddetg3*gu13))*INV(detg))/6.;
-    
-    G233  =  ((6*detg*Gt233 - g33*(ddetg1*gu12 + ddetg2*gu22 + ddetg3*gu23))*INV(detg))/6.;
-    
-    G333  =  -((-6*detg*Gt333 + g33*(ddetg1*gu13 + ddetg2*gu23) + ddetg3*(-6 + g33*gu33))*INV(detg))/6.;
-    
-    Rt11  =  -(gtu11*khalf*PDstandard4th11gt11) + gtu12*
-         (2*Gt211*Gt221*gt22L + 4*gt21L*Gt232*Gt311 + 6*Gt121*Gt311*gt31L + 4*gt11L*Gt131*Gt321 + 4*Gt221*gt31L*Gt321 + 
-           4*Gt211*gt31L*Gt322 + 2*Gt221*Gt311*gt32L + 2*Gt211*Gt321*gt32L + 4*gt31L*Gt321*Gt331 + 4*Gt311*gt31L*Gt332 + 
-           2*Gt311*Gt321*gt33L - PDstandard4th12gt11) + 
-        gtu13*(2*Gt231*Gt311*gt32L + 4*gt11L*Gt131*Gt331 + 2*Gt211*gt32L*Gt331 + 4*Gt211*gt31L*Gt332 + 
-           4*Gt311*gt31L*Gt333 + 2*Gt311*Gt331*gt33L - PDstandard4th13gt11) + 2*gt11L*PDstandard4th1Xt1 + 
-        gt21L*(6*Gt111*Gt221*gtu12 + 4*Gt211*Gt222*gtu12 + 6*Gt131*Gt211*gtu13 + 6*Gt121*Gt221*gtu22 + 
-           6*Gt131*Gt221*gtu23 + 6*Gt131*Gt231*gtu33 + 2*PDstandard4th1Xt2) + 2*gt31L*PDstandard4th1Xt3 - 
-        gtu22*khalf*PDstandard4th22gt11 - gtu23*PDstandard4th23gt11 - gtu33*khalf*PDstandard4th33gt11 + 
-        Gt111*(10*gt11L*Gt131*gtu13 + 6*gt21L*Gt231*gtu13 + 2*gt11L*Xt1L) + 
-        Gt211*(4*gt11L*Gt121*gtu11 + 6*Gt111*gt21L*gtu11 + 4*gt31L*Gt321*gtu11 + 2*Gt311*gt32L*gtu11 + 
-           4*gt11L*Gt122*gtu12 + 4*gt11L*Gt132*gtu13 + 2*gt22L*Gt231*gtu13 + 4*gt21L*Gt232*gtu13 + 2*gt21L*Xt1L) + 
-        Gt311*(4*gt21L*Gt231*gtu11 + 6*Gt111*gt31L*gtu11 + 4*gt11L*Gt132*gtu12 + 4*gt11L*Gt133*gtu13 + 
-           4*gt21L*Gt233*gtu13 + 6*Gt131*gt31L*gtu13 + 2*gt31L*Xt1L) + 
-        Gt121*(10*Gt111*gt11L*gtu12 + 6*Gt211*gt21L*gtu12 + 4*gt11L*Gt231*gtu13 + 6*gt31L*Gt321*gtu22 + 
-           10*gt11L*Gt131*gtu23 + 2*gt11L*Xt2L) + Gt221*
-         (4*gt31L*Gt322*gtu22 + 2*Gt321*gt32L*gtu22 + 2*gt22L*Gt231*gtu23 + 2*gt32L*Gt331*gtu23 + 4*gt31L*Gt332*gtu23 + 
-           2*gt21L*Xt2L) + Gt321*(4*gt21L*Gt231*gtu12 + 6*Gt111*gt31L*gtu12 + 4*Gt231*gt31L*gtu13 + 4*gt11L*Gt132*gtu22 + 
-           4*gt31L*Gt332*gtu22 + 4*gt11L*Gt133*gtu23 + 4*gt21L*Gt233*gtu23 + 6*Gt131*gt31L*gtu23 + 2*gt31L*Xt2L) + 
-        2*gt11L*Gt131*Xt3L + Gt231*(4*gt11L*Gt122*gtu23 + 6*Gt121*gt21L*gtu23 + 4*gt31L*Gt322*gtu23 + 2*Gt321*gt32L*gtu23 + 
-           4*gt11L*Gt132*gtu33 + 2*gt32L*Gt331*gtu33 + 4*gt31L*Gt332*gtu33 + 2*gt21L*Xt3L) + 
-        Gt331*(4*gt21L*Gt231*gtu13 + 6*Gt111*gt31L*gtu13 + 4*gt11L*Gt132*gtu23 + 4*gt21L*Gt232*gtu23 + 
-           6*Gt121*gt31L*gtu23 + 2*Gt321*gt33L*gtu23 + 4*gt11L*Gt133*gtu33 + 4*gt21L*Gt233*gtu33 + 6*Gt131*gt31L*gtu33 + 
-           4*gt31L*Gt333*gtu33 + 2*gt31L*Xt3L) + 5*gt11L*gtu11*SQR(Gt111) + 5*gt11L*gtu22*SQR(Gt121) + 
-        5*gt11L*gtu33*SQR(Gt131) + gt22L*gtu11*SQR(Gt211) + gt22L*gtu22*SQR(Gt221) + 
-        4*(Gt211*gt21L*Gt221*gtu11 + gt11L*Gt131*Gt311*gtu11 + Gt311*gt31L*Gt331*gtu11 + gt11L*Gt121*Gt221*gtu12 + 
-           gt21L*Gt221*Gt231*gtu13 + gt11L*Gt122*Gt221*gtu22 + gt21L*Gt221*Gt222*gtu22 + gt21L*Gt232*Gt321*gtu22 + 
-           gt11L*Gt132*Gt221*gtu23 + gt21L*Gt222*Gt231*gtu23 + gt21L*Gt221*Gt232*gtu23 + gt31L*Gt331*Gt332*gtu23 + 
-           gt31L*Gt321*Gt333*gtu23 + gt21L*Gt231*Gt232*gtu33 + gt21L*gtu12*SQR(Gt221)) + gt22L*gtu33*SQR(Gt231) + 
-        gt33L*gtu11*SQR(Gt311) + gt33L*gtu22*SQR(Gt321) + 4*gt31L*gtu13*SQR(Gt331) + gt33L*gtu33*SQR(Gt331);
-    
-    Rt21  =  gt22L*PDstandard4th1Xt2 + gt32L*PDstandard4th1Xt3 + gt11L*PDstandard4th2Xt1 + 
-        gt21L*(PDstandard4th1Xt1 + PDstandard4th2Xt2) + gt31L*PDstandard4th2Xt3 + 
-        khalf*(-(gtu11*PDstandard4th11gt21) - 2*gtu12*PDstandard4th12gt21 - 2*gtu13*PDstandard4th13gt21 - 
-           gtu22*PDstandard4th22gt21 - 2*gtu23*PDstandard4th23gt21 - gtu33*PDstandard4th33gt21) + 
-        (gt11L*Gt121 + gt21L*(Gt111 + Gt221) + Gt211*gt22L + gt31L*Gt321 + Gt311*gt32L)*Xt1L + 
-        (gt11L*Gt122 + gt21L*(Gt121 + Gt222) + Gt221*gt22L + gt31L*Gt322 + Gt321*gt32L)*Xt2L + 
-        (gt11L*Gt132 + gt22L*Gt231 + gt21L*(Gt131 + Gt232) + gt32L*Gt331 + gt31L*Gt332)*Xt3L + 
-        gtu11*(gt11L*(Gt121*(3*Gt111 + 2*Gt221) + 2*Gt131*Gt321) + 
-           Gt111*(gt21L*Gt221 + gt31L*Gt321 + 2*(Gt211*gt22L + Gt311*gt32L)) + 
-           Gt211*(5*Gt121*gt21L + 3*(Gt221*gt22L + Gt321*gt32L)) + gt31L*(3*Gt121*Gt311 + 2*Gt321*(Gt221 + Gt331)) + 
-           Gt311*(Gt221*gt32L + Gt321*gt33L) + 2*(Gt311*(Gt131*gt21L + gt22L*Gt231 + gt32L*Gt331) + 
-              gt21L*(Gt231*Gt321 + SQR(Gt111) + SQR(Gt221)))) + 
-        gtu22*(gt11L*(Gt122*(3*Gt121 + 2*Gt222) + 2*Gt132*Gt322) + 
-           Gt121*(gt21L*Gt222 + gt31L*Gt322 + 2*(Gt221*gt22L + Gt321*gt32L)) + 
-           Gt221*(5*Gt122*gt21L + 3*(Gt222*gt22L + Gt322*gt32L)) + gt31L*(3*Gt122*Gt321 + 2*Gt322*(Gt222 + Gt332)) + 
-           Gt321*(Gt222*gt32L + Gt322*gt33L) + 2*(Gt321*(Gt132*gt21L + gt22L*Gt232 + gt32L*Gt332) + 
-              gt21L*(Gt232*Gt322 + SQR(Gt121) + SQR(Gt222)))) + 
-        gtu33*(gt11L*(Gt132*(3*Gt131 + 2*Gt232) + 2*Gt133*Gt332) + 
-           Gt131*(gt21L*Gt232 + 2*(gt22L*Gt231 + gt32L*Gt331) + gt31L*Gt332) + 
-           Gt231*(5*Gt132*gt21L + 3*(gt22L*Gt232 + gt32L*Gt332)) + 
-           Gt331*(3*Gt132*gt31L + gt32L*(Gt232 + 2*Gt333) + Gt332*gt33L) + 
-           2*((Gt133*gt21L + gt22L*Gt233)*Gt331 + Gt332*(gt21L*Gt233 + gt31L*(Gt232 + Gt333)) + 
-              gt21L*(SQR(Gt131) + SQR(Gt232)))) + gtu12*
-         (Gt122*(Gt111*gt11L + 3*Gt211*gt21L + Gt311*gt31L) + 
-           gt21L*(Gt111*Gt222 + Gt221*(4*Gt121 + 2*Gt222) + 2*(Gt132*Gt311 + Gt232*Gt321)) + 
-           gt31L*((Gt111 + 2*Gt221)*Gt322 + Gt321*(4*Gt121 + 2*Gt332)) + 
-           gt32L*(2*Gt221*Gt321 + 3*Gt211*Gt322 + Gt311*(Gt222 + 2*Gt332)) + 
-           gt11L*(2*(Gt122*Gt221 + Gt132*Gt321) + 3*SQR(Gt121)) + gt22L*(3*Gt211*Gt222 + 2*Gt232*Gt311 + SQR(Gt221)) + 
-           2*(gt11L*(Gt111*Gt122 + Gt121*Gt222 + Gt131*Gt322) + 
-              gt21L*(Gt122*Gt211 + Gt121*(Gt111 + Gt221) + Gt221*Gt222 + Gt131*Gt321 + Gt231*Gt322) + 
-              Gt111*(Gt121*gt21L + Gt221*gt22L + Gt321*gt32L) + gt31L*(Gt122*Gt311 + Gt222*Gt321 + Gt322*Gt331) + 
-              gt32L*(Gt121*Gt311 + Gt321*(Gt221 + Gt331)) + gt22L*(Gt121*Gt211 + Gt231*Gt321 + SQR(Gt221))) + 
-           gt33L*(Gt311*Gt322 + SQR(Gt321))) + gtu13*
-         (gt22L*(3*Gt211*Gt232 + 2*Gt233*Gt311) + Gt132*(Gt111*gt11L + 3*Gt211*gt21L + Gt311*gt31L) + 
-           gt11L*(3*Gt121*Gt131 + 2*(Gt132*Gt221 + Gt133*Gt321)) + 
-           gt21L*(Gt131*Gt221 + 3*Gt121*Gt231 + Gt111*Gt232 + 2*(Gt133*Gt311 + Gt233*Gt321)) + 
-           Gt221*(gt22L*Gt231 + 2*gt21L*Gt232 + gt32L*Gt331) + gt31L*(3*Gt121*Gt331 + Gt111*Gt332) + 
-           gt32L*(3*Gt211*Gt332 + Gt311*(Gt232 + 2*Gt333)) + Gt311*Gt332*gt33L + 
-           Gt321*(Gt231*gt32L + gt31L*(Gt131 + 2*Gt333) + Gt331*gt33L) + 
-           2*(Gt111*(Gt131*gt21L + gt22L*Gt231 + gt32L*Gt331) + gt22L*(Gt131*Gt211 + Gt231*(Gt221 + Gt331)) + 
-              gt11L*(Gt111*Gt132 + Gt121*Gt232 + Gt131*Gt332) + gt31L*(Gt132*Gt311 + Gt232*Gt321 + (Gt221 + Gt331)*Gt332) + 
-              gt21L*(Gt132*Gt211 + Gt221*Gt232 + Gt131*(Gt111 + Gt331) + Gt231*(Gt121 + Gt332)) + 
-              gt32L*(Gt131*Gt311 + Gt231*Gt321 + SQR(Gt331)))) + 
-        gtu23*(gt22L*(3*Gt221*Gt232 + 2*Gt233*Gt321) + Gt132*(gt11L*Gt121 + 3*gt21L*Gt221 + gt31L*Gt321) + 
-           gt11L*(3*Gt122*Gt131 + 2*(Gt132*Gt222 + Gt133*Gt322)) + 
-           gt21L*(Gt131*Gt222 + 3*Gt122*Gt231 + Gt121*Gt232 + 2*(Gt133*Gt321 + Gt233*Gt322)) + 
-           Gt222*(gt22L*Gt231 + 2*gt21L*Gt232 + gt32L*Gt331) + gt31L*(3*Gt122*Gt331 + Gt121*Gt332) + 
-           gt32L*(3*Gt221*Gt332 + Gt321*(Gt232 + 2*Gt333)) + Gt321*Gt332*gt33L + 
-           Gt322*(Gt231*gt32L + gt31L*(Gt131 + 2*Gt333) + Gt331*gt33L) + 
-           2*(Gt131*(Gt121*gt21L + Gt221*gt22L + Gt321*gt32L) + Gt231*(Gt122*gt21L + Gt222*gt22L + Gt322*gt32L) + 
-              Gt121*(Gt131*gt21L + gt22L*Gt231 + gt32L*Gt331) + Gt331*(Gt132*gt21L + gt22L*Gt232 + gt32L*Gt332) + 
-              gt11L*(Gt122*Gt232 + Gt132*(Gt121 + Gt332)) + gt21L*(Gt132*Gt221 + Gt232*(Gt222 + Gt332)) + 
-              gt31L*(Gt132*Gt321 + Gt232*Gt322 + Gt222*Gt332 + SQR(Gt332))));
-    
-    Rt31  =  gt32L*PDstandard4th1Xt2 + gt33L*PDstandard4th1Xt3 + 
-        khalf*(-(gtu11*PDstandard4th11gt31) - 2*gtu12*PDstandard4th12gt31 - 2*gtu13*PDstandard4th13gt31 - 
-           gtu22*PDstandard4th22gt31 - 2*gtu23*PDstandard4th23gt31 - gtu33*PDstandard4th33gt31) + gt11L*PDstandard4th3Xt1 + 
-        gt21L*PDstandard4th3Xt2 + gt31L*(PDstandard4th1Xt1 + PDstandard4th3Xt3) + 
-        (gt11L*Gt131 + gt21L*Gt231 + Gt211*gt32L + gt31L*(Gt111 + Gt331) + Gt311*gt33L)*Xt1L + 
-        (gt11L*Gt132 + gt21L*Gt232 + Gt221*gt32L + gt31L*(Gt121 + Gt332) + Gt321*gt33L)*Xt2L + 
-        (gt11L*Gt133 + gt21L*Gt233 + Gt231*gt32L + gt31L*(Gt131 + Gt333) + Gt331*gt33L)*Xt3L + 
-        gtu12*(gt22L*(Gt221*Gt231 + Gt211*Gt232) + Gt132*(Gt111*gt11L + Gt211*gt21L + 3*Gt311*gt31L) + 
-           gt21L*((Gt121 + 2*Gt222)*Gt231 + Gt232*(Gt111 + 2*Gt331)) + 
-           gt11L*(3*Gt121*Gt131 + 2*(Gt122*Gt231 + Gt132*Gt331)) + gt31L*(Gt121*Gt331 + Gt111*Gt332) + 
-           gt32L*(Gt231*Gt321 + Gt221*Gt331 + Gt211*(2*Gt222 + Gt332)) + (2*Gt211*Gt322 + Gt321*Gt331)*gt33L + 
-           3*(Gt131*(gt21L*Gt221 + gt31L*Gt321) + Gt311*(Gt232*gt32L + Gt332*gt33L)) + 
-           2*(gt11L*(Gt111*Gt132 + Gt121*Gt232 + Gt131*Gt332) + gt21L*(Gt132*Gt211 + Gt221*Gt232 + Gt231*Gt332) + 
-              gt31L*(Gt122*Gt211 + Gt121*(2*Gt111 + Gt221) + Gt132*Gt311 + (Gt131 + Gt232)*Gt321 + Gt231*Gt322 + 
-                 2*Gt331*Gt332) + (Gt121*Gt311 + Gt321*(Gt221 + Gt331))*gt33L + Gt111*(Gt221*gt32L + Gt321*gt33L) + 
-              gt32L*(Gt121*Gt211 + Gt231*Gt321 + SQR(Gt221)))) + 
-        gtu23*(Gt233*(Gt221*gt22L + 2*gt31L*Gt322 + Gt321*gt32L) + Gt132*(gt11L*Gt131 + gt21L*Gt231 + 3*gt31L*Gt331) + 
-           Gt232*(Gt131*gt21L + gt22L*Gt231 + 3*gt32L*Gt331) + (Gt131*gt31L + Gt231*gt32L)*Gt332 + 
-           gt21L*((Gt121 + 2*Gt222)*Gt233 + 2*Gt232*Gt333) + gt11L*(3*Gt121*Gt133 + 2*(Gt122*Gt233 + Gt132*Gt333)) + 
-           Gt333*(Gt121*gt31L + Gt221*gt32L + Gt321*gt33L) + 3*(Gt133*(gt21L*Gt221 + gt31L*Gt321) + Gt331*Gt332*gt33L) + 
-           2*((Gt222*Gt231 + Gt221*(Gt131 + Gt232) + Gt233*Gt321)*gt32L + gt11L*(Gt132*(Gt131 + Gt232) + Gt133*Gt332) + 
-              gt31L*(Gt121*Gt131 + Gt122*Gt231 + Gt133*Gt321 + Gt132*(Gt221 + Gt331) + Gt332*(Gt232 + 2*Gt333)) + 
-              (Gt231*Gt322 + Gt221*Gt332 + Gt321*(Gt131 + Gt333))*gt33L + Gt121*(Gt131*gt31L + Gt231*gt32L + Gt331*gt33L) + 
-              gt21L*(Gt132*Gt231 + Gt233*Gt332 + SQR(Gt232)))) + 
-        gtu11*(Gt231*(Gt211*gt22L + 2*(gt21L*Gt221 + gt31L*Gt321) + 3*Gt311*gt32L) + 
-           gt21L*(3*Gt131*Gt211 + Gt231*(Gt111 + 2*Gt331)) + gt11L*(2*Gt121*Gt231 + Gt131*(3*Gt111 + 2*Gt331)) + 
-           3*Gt311*Gt331*gt33L + Gt211*(gt32L*Gt331 + 2*Gt321*gt33L) + 
-           gt31L*(5*Gt131*Gt311 + Gt111*Gt331 + 2*(Gt121*Gt211 + SQR(Gt111))) + 
-           2*(Gt211*(Gt111 + Gt221)*gt32L + Gt111*Gt311*gt33L + gt31L*SQR(Gt331))) + 
-        gtu13*(Gt133*(Gt111*gt11L + Gt211*gt21L + 3*Gt311*gt31L) + gt32L*(3*Gt233*Gt311 + 2*Gt231*(Gt111 + Gt331)) + 
-           gt21L*(Gt111*Gt233 + 2*(Gt231*Gt232 + Gt233*Gt331)) + Gt111*(gt31L*Gt333 + 2*Gt331*gt33L) + 
-           Gt211*(gt22L*Gt233 + gt32L*Gt333 + 2*(Gt132*gt31L + Gt232*gt32L + Gt332*gt33L)) + 
-           gt11L*(2*(Gt132*Gt231 + Gt133*Gt331) + 3*SQR(Gt131)) + gt22L*SQR(Gt231) + gt33L*(3*Gt311*Gt333 + SQR(Gt331)) + 
-           2*(gt32L*(Gt131*Gt211 + Gt231*(Gt221 + Gt331)) + Gt131*(Gt111*gt31L + 2*(gt21L*Gt231 + gt31L*Gt331)) + 
-              gt11L*(Gt111*Gt133 + Gt121*Gt233 + Gt131*Gt333) + gt21L*(Gt133*Gt211 + Gt221*Gt233 + Gt231*Gt333) + 
-              gt31L*(Gt133*Gt311 + Gt233*Gt321 + Gt131*(Gt111 + Gt331) + Gt231*(Gt121 + Gt332) + 2*Gt331*Gt333) + 
-              gt33L*(Gt131*Gt311 + Gt231*Gt321 + SQR(Gt331)))) + 
-        gtu22*(Gt232*(Gt221*gt22L + 2*(gt21L*Gt222 + gt31L*Gt322) + 3*Gt321*gt32L) + 
-           gt21L*(3*Gt132*Gt221 + Gt232*(Gt121 + 2*Gt332)) + gt11L*(2*Gt122*Gt232 + Gt132*(3*Gt121 + 2*Gt332)) + 
-           3*Gt321*Gt332*gt33L + Gt221*(gt32L*Gt332 + 2*Gt322*gt33L) + 
-           gt31L*(5*Gt132*Gt321 + Gt121*Gt332 + 2*(Gt122*Gt221 + SQR(Gt121))) + 
-           2*(Gt221*(Gt121 + Gt222)*gt32L + Gt121*Gt321*gt33L + gt31L*SQR(Gt332))) + 
-        gtu33*(Gt233*(gt22L*Gt231 + 2*gt21L*Gt232 + 3*gt32L*Gt331) + gt21L*(3*Gt133*Gt231 + Gt233*(Gt131 + 2*Gt333)) + 
-           gt11L*(2*Gt132*Gt233 + Gt133*(3*Gt131 + 2*Gt333)) + 3*Gt331*Gt333*gt33L + Gt231*(gt32L*Gt333 + 2*Gt332*gt33L) + 
-           gt31L*(5*Gt133*Gt331 + Gt131*Gt333 + 2*SQR(Gt131)) + 
-           2*(Gt231*(Gt132*gt31L + (Gt131 + Gt232)*gt32L) + Gt131*Gt331*gt33L + gt31L*(Gt233*Gt332 + SQR(Gt333))));
-    
-    Rt22  =  6*(Gt122*gt21L*Gt221*gtu12 + Gt121*gt21L*Gt222*gtu12 + Gt222*Gt321*gt32L*gtu12 + Gt221*Gt322*gt32L*gtu12 + 
-           Gt132*gt21L*Gt221*gtu13 + Gt122*gt21L*Gt222*gtu22 + Gt132*gt21L*Gt222*gtu23 + Gt232*gt32L*Gt332*gtu33) - 
-        gtu11*khalf*PDstandard4th11gt22 + gtu12*(2*Gt122*gt31L*Gt321 + 4*Gt131*gt21L*Gt322 + 4*Gt121*Gt321*gt32L + 
-           4*Gt322*gt32L*Gt331 + 4*Gt321*gt32L*Gt332 + 2*Gt321*Gt322*gt33L - PDstandard4th12gt22) - 
-        gtu13*PDstandard4th13gt22 - gtu22*khalf*PDstandard4th22gt22 + 
-        gtu23*(2*Gt132*gt31L*Gt322 + 4*Gt122*gt32L*Gt331 + 4*gt22L*Gt232*Gt332 + 4*Gt322*gt32L*Gt333 + 
-           2*Gt322*Gt332*gt33L - PDstandard4th23gt22) + 2*gt21L*PDstandard4th2Xt1 + 
-        gt22L*(10*Gt221*Gt222*gtu12 + 4*Gt232*Gt321*gtu12 + 4*Gt132*Gt211*gtu13 + 4*Gt122*Gt221*gtu22 + 
-           4*Gt132*Gt221*gtu23 + 10*Gt222*Gt232*gtu23 + 4*Gt233*Gt322*gtu23 + 4*Gt132*Gt231*gtu33 + 2*PDstandard4th2Xt2) + 
-        gt32L*(4*Gt121*Gt311*gtu11 + 6*Gt221*Gt321*gtu11 + 4*Gt122*Gt311*gtu12 + 4*Gt132*Gt311*gtu13 + 
-           6*Gt232*Gt321*gtu13 + 4*Gt121*Gt331*gtu13 + 4*Gt122*Gt321*gtu22 + 6*Gt232*Gt322*gtu23 + 4*Gt132*Gt331*gtu33 + 
-           2*PDstandard4th2Xt3) - gtu33*khalf*PDstandard4th33gt22 + 2*Gt221*gt22L*Xt1L + 
-        Gt121*(4*Gt111*gt21L*gtu11 + 6*gt21L*Gt221*gtu11 + 2*gt11L*Gt122*gtu12 + 2*gt11L*Gt132*gtu13 + 
-           4*Gt122*gt21L*gtu22 + 4*Gt132*gt21L*gtu23 + 2*gt21L*Xt1L) + 
-        Gt321*(4*gt22L*Gt231*gtu11 + 2*Gt121*gt31L*gtu11 + 4*gt32L*Gt331*gtu11 + 4*Gt132*gt21L*gtu12 + 
-           4*Gt133*gt21L*gtu13 + 4*gt22L*Gt233*gtu13 + 2*Gt132*gt31L*gtu13 + 2*Gt332*gt33L*gtu13 + 4*Gt132*gt32L*gtu23 + 
-           2*gt32L*Xt1L) + 2*Gt222*gt22L*Xt2L + Gt122*(2*gt11L*Gt132*gtu23 + 4*gt22L*Gt231*gtu23 + 2*gt21L*Xt2L) + 
-        Gt322*(4*gt22L*Gt231*gtu12 + 2*Gt121*gt31L*gtu12 + 4*Gt132*gt21L*gtu22 + 2*Gt122*gt31L*gtu22 + 
-           6*Gt222*gt32L*gtu22 + 4*Gt133*gt21L*gtu23 + 2*gt32L*Xt2L) + 2*Gt132*gt21L*Xt3L + 
-        Gt232*(6*Gt121*gt21L*gtu13 + 10*Gt221*gt22L*gtu13 + 4*gt22L*Gt322*gtu22 + 6*Gt122*gt21L*gtu23 + 
-           6*Gt132*gt21L*gtu33 + 2*gt22L*Xt3L) + Gt332*
-         (2*Gt121*gt31L*gtu13 + 6*Gt221*gt32L*gtu13 + 4*Gt322*gt32L*gtu22 + 4*Gt132*gt21L*gtu23 + 2*Gt122*gt31L*gtu23 + 
-           6*Gt222*gt32L*gtu23 + 4*Gt133*gt21L*gtu33 + 4*gt22L*Gt233*gtu33 + 2*Gt132*gt31L*gtu33 + 2*gt32L*Xt3L) + 
-        gt11L*gtu11*SQR(Gt121) + 4*(Gt121*Gt211*gt22L*gtu11 + Gt131*gt21L*Gt321*gtu11 + Gt111*Gt122*gt21L*gtu12 + 
-           Gt122*Gt211*gt22L*gtu12 + Gt121*Gt221*gt22L*gtu12 + Gt121*Gt131*gt21L*gtu13 + Gt111*Gt132*gt21L*gtu13 + 
-           Gt121*gt22L*Gt231*gtu13 + Gt131*gt21L*Gt332*gtu13 + gt22L*Gt231*Gt332*gtu13 + gt32L*Gt331*Gt332*gtu13 + 
-           Gt321*gt32L*Gt333*gtu13 + Gt122*Gt131*gt21L*gtu23 + Gt131*Gt132*gt21L*gtu33 + gt32L*Gt332*Gt333*gtu33 + 
-           gt21L*gtu12*SQR(Gt121)) + gt11L*gtu22*SQR(Gt122) + gt11L*gtu33*SQR(Gt132) + 5*gt22L*gtu11*SQR(Gt221) + 
-        5*gt22L*gtu22*SQR(Gt222) + 5*gt22L*gtu33*SQR(Gt232) + gt33L*gtu11*SQR(Gt321) + gt33L*gtu22*SQR(Gt322) + 
-        4*gt32L*gtu23*SQR(Gt332) + gt33L*gtu33*SQR(Gt332);
-    
-    Rt32  =  gt31L*PDstandard4th2Xt1 + gt33L*PDstandard4th2Xt3 + 
-        khalf*(-(gtu11*PDstandard4th11gt32) - 2*gtu12*PDstandard4th12gt32 - 2*gtu13*PDstandard4th13gt32 - 
-           gtu22*PDstandard4th22gt32 - 2*gtu23*PDstandard4th23gt32 - gtu33*PDstandard4th33gt32) + gt21L*PDstandard4th3Xt1 + 
-        gt22L*PDstandard4th3Xt2 + gt32L*(PDstandard4th2Xt2 + PDstandard4th3Xt3) + 
-        (Gt131*gt21L + gt22L*Gt231 + Gt121*gt31L + gt32L*(Gt221 + Gt331) + Gt321*gt33L)*Xt1L + 
-        (Gt132*gt21L + gt22L*Gt232 + Gt122*gt31L + gt32L*(Gt222 + Gt332) + Gt322*gt33L)*Xt2L + 
-        (Gt133*gt21L + gt22L*Gt233 + Gt132*gt31L + gt32L*(Gt232 + Gt333) + Gt332*gt33L)*Xt3L + 
-        gtu12*(gt11L*(Gt122*Gt131 + Gt121*Gt132) + gt32L*
-            (2*(Gt132*Gt311 + Gt131*Gt321) + 5*(Gt232*Gt321 + Gt231*Gt322) + Gt222*(4*Gt221 + Gt331) + 
-              (Gt221 + 4*Gt331)*Gt332) + gt21L*(3*Gt122*Gt231 + Gt132*(Gt221 + 2*Gt331) + Gt131*(Gt222 + 2*Gt332)) + 
-           3*(Gt121*gt21L*Gt232 + gt22L*(Gt222*Gt231 + Gt221*Gt232) + gt31L*(Gt132*Gt321 + Gt131*Gt322) + 
-              (Gt322*Gt331 + Gt321*Gt332)*gt33L) + 2*
-            ((Gt122*Gt221 + Gt121*Gt222)*gt31L + Gt111*(Gt132*gt21L + Gt122*gt31L) + 
-              gt22L*(Gt132*Gt211 + Gt131*Gt221 + Gt232*Gt331 + Gt231*Gt332) + (Gt222*Gt321 + Gt221*Gt322)*gt33L + 
-              Gt122*(Gt211*gt32L + Gt311*gt33L) + Gt121*(Gt131*gt21L + Gt221*gt32L + Gt321*gt33L)) + 
-           gt31L*(Gt122*Gt331 + Gt121*Gt332 + 2*SQR(Gt121))) + 
-        gtu13*(gt11L*(Gt131*Gt132 + Gt121*Gt133) + Gt133*(gt21L*Gt221 + 3*gt31L*Gt321 + 2*(Gt211*gt22L + Gt311*gt32L)) + 
-           gt32L*(5*Gt233*Gt321 + Gt232*(4*Gt221 + Gt331) + Gt231*(2*Gt121 + 5*Gt332) + Gt221*Gt333) + 
-           Gt331*(2*gt22L*Gt233 + Gt132*gt31L + 4*gt32L*Gt333) + 
-           Gt131*(2*(gt22L*Gt231 + Gt121*gt31L + gt32L*Gt331) + gt31L*Gt332 + gt21L*(Gt232 + 2*Gt333)) + 
-           Gt121*(gt31L*Gt333 + 2*Gt331*gt33L) + 3*(Gt231*(Gt132*gt21L + gt22L*Gt232) + (Gt121*gt21L + Gt221*gt22L)*Gt233 + 
-              (Gt331*Gt332 + Gt321*Gt333)*gt33L) + 2*
-            (Gt111*(Gt133*gt21L + Gt132*gt31L) + gt31L*(Gt132*Gt221 + Gt121*Gt232 + Gt131*Gt332) + gt22L*Gt231*Gt333 + 
-              (Gt232*Gt321 + Gt221*Gt332)*gt33L + Gt132*(Gt211*gt32L + Gt311*gt33L) + gt21L*(Gt133*Gt331 + SQR(Gt131)))) + 
-        gtu11*(Gt131*(gt11L*Gt121 + gt21L*Gt221 + 3*gt31L*Gt321 + 2*(Gt211*gt22L + Gt311*gt32L)) + 
-           (Gt121*gt31L + Gt221*gt32L)*Gt331 + Gt231*(5*Gt321*gt32L + 2*gt22L*Gt331) + 
-           3*((Gt121*gt21L + Gt221*gt22L)*Gt231 + Gt321*Gt331*gt33L) + 
-           2*(Gt111*(Gt131*gt21L + Gt121*gt31L) + Gt131*gt21L*Gt331 + Gt221*Gt321*gt33L + 
-              Gt121*(Gt221*gt31L + Gt211*gt32L + Gt311*gt33L) + gt32L*(SQR(Gt221) + SQR(Gt331)))) + 
-        gtu23*(Gt233*(Gt122*gt21L + Gt222*gt22L + 3*Gt322*gt32L) + 
-           Gt133*(gt11L*Gt122 + 3*gt31L*Gt322 + gt21L*(Gt222 + 2*Gt332)) + 
-           Gt132*(4*gt21L*Gt232 + 2*(gt22L*Gt231 + gt32L*Gt331 + gt31L*(Gt222 + Gt332))) + 
-           gt32L*(4*Gt232*Gt332 + Gt222*Gt333) + Gt122*(gt31L*Gt333 + 2*Gt331*gt33L) + gt11L*SQR(Gt132) + 
-           3*(Gt322*Gt333*gt33L + gt22L*SQR(Gt232)) + gt33L*SQR(Gt332) + 
-           2*(Gt131*(Gt132*gt21L + Gt122*gt31L) + Gt133*(Gt121*gt21L + Gt221*gt22L + Gt321*gt32L) + 
-              gt31L*(Gt122*Gt232 + Gt132*(Gt121 + Gt332)) + Gt233*(Gt122*gt21L + Gt322*gt32L + gt22L*(Gt222 + Gt332)) + 
-              (Gt132*gt21L + gt22L*Gt232)*Gt333 + gt32L*
-               (Gt132*Gt221 + Gt122*Gt231 + Gt232*(2*Gt222 + Gt332) + 2*Gt332*Gt333) + 
-              gt33L*(Gt132*Gt321 + Gt232*Gt322 + Gt222*Gt332 + SQR(Gt332)))) + 
-        gtu22*(Gt132*(gt11L*Gt122 + gt21L*Gt222 + 3*gt31L*Gt322 + 2*(Gt221*gt22L + Gt321*gt32L)) + 
-           (Gt122*gt31L + Gt222*gt32L)*Gt332 + Gt232*(5*Gt322*gt32L + 2*gt22L*Gt332) + 
-           3*((Gt122*gt21L + Gt222*gt22L)*Gt232 + Gt322*Gt332*gt33L) + 
-           2*(Gt121*(Gt132*gt21L + Gt122*gt31L) + Gt132*gt21L*Gt332 + Gt222*Gt322*gt33L + 
-              Gt122*(Gt222*gt31L + Gt221*gt32L + Gt321*gt33L) + gt32L*(SQR(Gt222) + SQR(Gt332)))) + 
-        gtu33*(Gt133*(gt11L*Gt132 + gt21L*Gt232 + 2*(gt22L*Gt231 + gt32L*Gt331)) + (Gt132*gt31L + Gt232*gt32L)*Gt333 + 
-           Gt233*(5*gt32L*Gt332 + 2*gt22L*Gt333) + 3*
-            ((Gt132*gt21L + gt22L*Gt232)*Gt233 + Gt332*(Gt133*gt31L + Gt333*gt33L)) + 
-           2*(Gt131*(Gt133*gt21L + Gt132*gt31L) + Gt133*gt21L*Gt333 + Gt232*Gt332*gt33L + 
-              Gt132*(Gt232*gt31L + Gt231*gt32L + Gt331*gt33L) + gt32L*(SQR(Gt232) + SQR(Gt333))));
-    
-    Rt33  =  6*(Gt133*gt31L*Gt331*gtu13 + Gt233*gt32L*Gt331*gtu13 + Gt131*gt31L*Gt333*gtu13 + Gt231*gt32L*Gt333*gtu13 + 
-           Gt132*gt31L*Gt332*gtu22 + Gt133*gt31L*Gt332*gtu23 + Gt132*gt31L*Gt333*gtu23 + Gt232*gt32L*Gt333*gtu23 + 
-           Gt133*gt31L*Gt333*gtu33) + gtu12*(2*gt22L*Gt231*Gt232 + 4*Gt111*Gt132*gt31L + 4*Gt132*Gt211*gt32L + 
-           4*Gt221*Gt232*gt32L + 6*Gt132*gt31L*Gt331 + 6*Gt232*gt32L*Gt331 + 6*Gt131*gt31L*Gt332 + 6*Gt231*gt32L*Gt332 + 
-           4*Gt132*Gt311*gt33L - PDstandard4th12gt33) - gtu13*PDstandard4th13gt33 - gtu22*khalf*PDstandard4th22gt33 - 
-        gtu23*PDstandard4th23gt33 - gtu33*khalf*PDstandard4th33gt33 + 
-        2*(Gt132*gt21L*Gt231*gtu12 + Gt131*gt21L*Gt232*gtu12 + Gt133*gt21L*Gt231*gtu13 + Gt131*gt21L*Gt233*gtu13 + 
-           gt22L*Gt231*Gt233*gtu13 + Gt132*gt21L*Gt232*gtu22 + gt11L*Gt132*Gt133*gtu23 + Gt132*gt21L*Gt233*gtu23 + 
-           gt22L*Gt232*Gt233*gtu23 + Gt133*gt21L*Gt233*gtu33 + gt31L*PDstandard4th3Xt1) + 2*gt32L*PDstandard4th3Xt2 + 
-        gt33L*(4*Gt231*Gt322*gtu12 + 10*Gt331*Gt332*gtu12 + 4*Gt133*Gt311*gtu13 + 4*Gt231*Gt332*gtu13 + 
-           10*Gt331*Gt333*gtu13 + 4*Gt132*Gt321*gtu22 + 4*Gt133*Gt321*gtu23 + 4*Gt133*Gt331*gtu33 + 2*PDstandard4th3Xt3) + 
-        2*Gt231*gt32L*Xt1L + 2*Gt331*gt33L*Xt1L + Gt131*
-         (2*gt21L*Gt231*gtu11 + 4*Gt111*gt31L*gtu11 + 2*gt11L*Gt132*gtu12 + 2*gt11L*Gt133*gtu13 + 4*Gt132*gt31L*gtu23 + 
-           4*Gt133*gt31L*gtu33 + 2*gt31L*Xt1L) + 2*Gt132*gt31L*Xt2L + 
-        Gt232*(4*Gt222*gt32L*gtu22 + 6*gt32L*Gt332*gtu22 + 2*Gt133*gt21L*gtu23 + 4*Gt233*gt32L*gtu33 + 2*gt32L*Xt2L) + 
-        Gt332*(4*Gt232*gt33L*gtu23 + 10*Gt333*gt33L*gtu23 + 4*Gt233*gt33L*gtu33 + 2*gt33L*Xt2L) + 2*Gt133*gt31L*Xt3L + 
-        2*Gt333*gt33L*Xt3L + Gt233*(4*Gt222*gt32L*gtu23 + 6*gt32L*Gt332*gtu23 + 4*Gt132*gt31L*gtu33 + 6*gt32L*Gt333*gtu33 + 
-           2*gt32L*Xt3L) + gtu11*(4*Gt221*Gt231*gt32L + 6*Gt131*gt31L*Gt331 + 6*Gt231*gt32L*Gt331 + 4*Gt131*Gt311*gt33L + 
-           4*Gt231*Gt321*gt33L - khalf*PDstandard4th11gt33 + gt11L*SQR(Gt131)) + 
-        4*(Gt121*Gt231*gt31L*gtu11 + Gt131*Gt211*gt32L*gtu11 + Gt121*Gt131*gt31L*gtu12 + Gt122*Gt231*gt31L*gtu12 + 
-           Gt121*Gt232*gt31L*gtu12 + Gt131*Gt221*gt32L*gtu12 + Gt222*Gt231*gt32L*gtu12 + Gt131*Gt321*gt33L*gtu12 + 
-           Gt232*Gt321*gt33L*gtu12 + Gt111*Gt133*gt31L*gtu13 + Gt132*Gt231*gt31L*gtu13 + Gt121*Gt233*gt31L*gtu13 + 
-           Gt133*Gt211*gt32L*gtu13 + Gt131*Gt231*gt32L*gtu13 + Gt231*Gt232*gt32L*gtu13 + Gt221*Gt233*gt32L*gtu13 + 
-           Gt233*Gt321*gt33L*gtu13 + Gt131*Gt331*gt33L*gtu13 + Gt121*Gt132*gt31L*gtu22 + Gt122*Gt232*gt31L*gtu22 + 
-           Gt132*Gt221*gt32L*gtu22 + Gt232*Gt322*gt33L*gtu22 + Gt121*Gt133*gt31L*gtu23 + Gt132*Gt232*gt31L*gtu23 + 
-           Gt122*Gt233*gt31L*gtu23 + Gt133*Gt221*gt32L*gtu23 + Gt132*Gt231*gt32L*gtu23 + Gt233*Gt322*gt33L*gtu23 + 
-           Gt132*Gt331*gt33L*gtu23 + Gt133*Gt231*gt32L*gtu33 + gt31L*gtu13*SQR(Gt131)) + gt11L*gtu22*SQR(Gt132) + 
-        gt11L*gtu33*SQR(Gt133) + gt22L*gtu11*SQR(Gt231) + gt22L*gtu22*SQR(Gt232) + 4*gt32L*gtu23*SQR(Gt232) + 
-        gt22L*gtu33*SQR(Gt233) + 5*gt33L*gtu11*SQR(Gt331) + 5*gt33L*gtu22*SQR(Gt332) + 5*gt33L*gtu33*SQR(Gt333);
-    
-    Rphi11  =  2*(-PDstandard4th11phi - gt11L*gtu11*PDstandard4th11phi - 2*gt11L*gtu12*PDstandard4th12phi - 
-          2*gt11L*gtu13*PDstandard4th13phi - gt11L*gtu22*PDstandard4th22phi - 2*gt11L*gtu23*PDstandard4th23phi - 
-          gt11L*gtu33*PDstandard4th33phi + Gt311*PDstandard4th3phi + gt11L*Gt311*gtu11*PDstandard4th3phi + 
-          2*gt11L*Gt321*gtu12*PDstandard4th3phi + 2*gt11L*Gt331*gtu13*PDstandard4th3phi + 
-          gt11L*Gt322*gtu22*PDstandard4th3phi + 2*gt11L*Gt332*gtu23*PDstandard4th3phi + 
-          gt11L*Gt333*gtu33*PDstandard4th3phi + PDstandard4th1phi*
-           (Gt111 + Gt111*gt11L*gtu11 + 2*gt11L*Gt121*gtu12 + 2*gt11L*Gt131*gtu13 + gt11L*Gt122*gtu22 + 
-             2*gt11L*Gt132*gtu23 + gt11L*Gt133*gtu33 - 4*gt11L*gtu12*PDstandard4th2phi - 4*gt11L*gtu13*PDstandard4th3phi) + 
-          PDstandard4th2phi*(Gt211 + gt11L*Gt211*gtu11 + 
-             gt11L*(2*Gt221*gtu12 + 2*Gt231*gtu13 + Gt222*gtu22 + 2*Gt232*gtu23 + Gt233*gtu33) - 
-             4*gt11L*gtu23*PDstandard4th3phi) + (2 - 2*gt11L*gtu11)*SQR(PDstandard4th1phi) - 
-          2*gt11L*gtu22*SQR(PDstandard4th2phi) - 2*gt11L*gtu33*SQR(PDstandard4th3phi));
-    
-    Rphi21  =  2*(-(gt21L*gtu11*PDstandard4th11phi) - PDstandard4th12phi - 2*gt21L*gtu12*PDstandard4th12phi - 
-          2*gt21L*gtu13*PDstandard4th13phi - gt21L*gtu22*PDstandard4th22phi - 2*gt21L*gtu23*PDstandard4th23phi - 
-          gt21L*gtu33*PDstandard4th33phi + Gt321*PDstandard4th3phi + gt21L*Gt311*gtu11*PDstandard4th3phi + 
-          2*gt21L*Gt321*gtu12*PDstandard4th3phi + 2*gt21L*Gt331*gtu13*PDstandard4th3phi + 
-          gt21L*Gt322*gtu22*PDstandard4th3phi + 2*gt21L*Gt332*gtu23*PDstandard4th3phi + 
-          gt21L*Gt333*gtu33*PDstandard4th3phi + PDstandard4th1phi*
-           (Gt121 + Gt111*gt21L*gtu11 + 2*Gt121*gt21L*gtu12 + 2*Gt131*gt21L*gtu13 + Gt122*gt21L*gtu22 + 
-             2*Gt132*gt21L*gtu23 + Gt133*gt21L*gtu33 + (2 - 4*gt21L*gtu12)*PDstandard4th2phi - 
-             4*gt21L*gtu13*PDstandard4th3phi) + PDstandard4th2phi*
-           (Gt221 + 2*gt21L*Gt221*gtu12 + gt21L*(Gt211*gtu11 + 2*Gt231*gtu13 + Gt222*gtu22 + 2*Gt232*gtu23 + Gt233*gtu33) - 
-             4*gt21L*gtu23*PDstandard4th3phi) - 2*gt21L*gtu11*SQR(PDstandard4th1phi) - 
-          2*gt21L*gtu22*SQR(PDstandard4th2phi) - 2*gt21L*gtu33*SQR(PDstandard4th3phi));
-    
-    Rphi31  =  2*(-PDstandard4th13phi + gt31L*(-(gtu11*PDstandard4th11phi) - 2*gtu12*PDstandard4th12phi - 
-             2*gtu13*PDstandard4th13phi) - gt31L*gtu22*PDstandard4th22phi - 2*gt31L*gtu23*PDstandard4th23phi - 
-          gt31L*gtu33*PDstandard4th33phi + Gt331*PDstandard4th3phi + Gt311*gt31L*gtu11*PDstandard4th3phi + 
-          2*gt31L*Gt321*gtu12*PDstandard4th3phi + 2*gt31L*Gt331*gtu13*PDstandard4th3phi + 
-          gt31L*Gt322*gtu22*PDstandard4th3phi + 2*gt31L*Gt332*gtu23*PDstandard4th3phi + 
-          gt31L*Gt333*gtu33*PDstandard4th3phi + PDstandard4th1phi*
-           (Gt131 + Gt111*gt31L*gtu11 + 2*Gt121*gt31L*gtu12 + 2*Gt131*gt31L*gtu13 + Gt122*gt31L*gtu22 + 
-             2*Gt132*gt31L*gtu23 + Gt133*gt31L*gtu33 - 4*gt31L*gtu12*PDstandard4th2phi + 
-             (2 - 4*gt31L*gtu13)*PDstandard4th3phi) + 
-          PDstandard4th2phi*(Gt231 + 2*Gt231*gt31L*gtu13 + 
-             gt31L*(Gt211*gtu11 + 2*Gt221*gtu12 + Gt222*gtu22 + 2*Gt232*gtu23 + Gt233*gtu33) - 
-             4*gt31L*gtu23*PDstandard4th3phi) - 2*gt31L*gtu11*SQR(PDstandard4th1phi) - 
-          2*gt31L*gtu22*SQR(PDstandard4th2phi) - 2*gt31L*gtu33*SQR(PDstandard4th3phi));
-    
-    Rphi22  =  2*(-PDstandard4th22phi + gt22L*(-(gtu11*PDstandard4th11phi) - 2*gtu12*PDstandard4th12phi - 
-             2*gtu13*PDstandard4th13phi - gtu22*PDstandard4th22phi) - 2*gt22L*gtu23*PDstandard4th23phi - 
-          gt22L*gtu33*PDstandard4th33phi + Gt322*PDstandard4th3phi + gt22L*Gt311*gtu11*PDstandard4th3phi + 
-          2*gt22L*Gt321*gtu12*PDstandard4th3phi + 2*gt22L*Gt331*gtu13*PDstandard4th3phi + 
-          gt22L*Gt322*gtu22*PDstandard4th3phi + 2*gt22L*Gt332*gtu23*PDstandard4th3phi + 
-          gt22L*Gt333*gtu33*PDstandard4th3phi + PDstandard4th1phi*
-           (Gt122 + Gt111*gt22L*gtu11 + 2*Gt121*gt22L*gtu12 + 2*Gt131*gt22L*gtu13 + Gt122*gt22L*gtu22 + 
-             2*Gt132*gt22L*gtu23 + Gt133*gt22L*gtu33 - 4*gt22L*gtu12*PDstandard4th2phi - 4*gt22L*gtu13*PDstandard4th3phi) + 
-          PDstandard4th2phi*(Gt222 + Gt222*gt22L*gtu22 + 
-             gt22L*(Gt211*gtu11 + 2*Gt221*gtu12 + 2*Gt231*gtu13 + 2*Gt232*gtu23 + Gt233*gtu33) - 
-             4*gt22L*gtu23*PDstandard4th3phi) - 2*gt22L*gtu11*SQR(PDstandard4th1phi) + 
-          (2 - 2*gt22L*gtu22)*SQR(PDstandard4th2phi) - 2*gt22L*gtu33*SQR(PDstandard4th3phi));
-    
-    Rphi32  =  2*(-PDstandard4th23phi + gt32L*(-(gtu11*PDstandard4th11phi) - 2*gtu12*PDstandard4th12phi - 
-             2*gtu13*PDstandard4th13phi - gtu22*PDstandard4th22phi - 2*gtu23*PDstandard4th23phi) - 
-          gt32L*gtu33*PDstandard4th33phi + Gt332*PDstandard4th3phi + Gt311*gt32L*gtu11*PDstandard4th3phi + 
-          2*Gt321*gt32L*gtu12*PDstandard4th3phi + 2*gt32L*Gt331*gtu13*PDstandard4th3phi + 
-          Gt322*gt32L*gtu22*PDstandard4th3phi + 2*gt32L*Gt332*gtu23*PDstandard4th3phi + 
-          gt32L*Gt333*gtu33*PDstandard4th3phi + PDstandard4th1phi*
-           (Gt132 + Gt111*gt32L*gtu11 + 2*Gt121*gt32L*gtu12 + 2*Gt131*gt32L*gtu13 + Gt122*gt32L*gtu22 + 
-             2*Gt132*gt32L*gtu23 + Gt133*gt32L*gtu33 - 4*gt32L*gtu12*PDstandard4th2phi - 4*gt32L*gtu13*PDstandard4th3phi) + 
-          PDstandard4th2phi*(Gt232 + 2*Gt232*gt32L*gtu23 + 
-             gt32L*(Gt211*gtu11 + 2*Gt221*gtu12 + 2*Gt231*gtu13 + Gt222*gtu22 + Gt233*gtu33) + 
-             (2 - 4*gt32L*gtu23)*PDstandard4th3phi) - 2*gt32L*gtu11*SQR(PDstandard4th1phi) - 
-          2*gt32L*gtu22*SQR(PDstandard4th2phi) - 2*gt32L*gtu33*SQR(PDstandard4th3phi));
-    
-    Rphi33  =  2*(-PDstandard4th33phi + (Gt333 + gt33L*
-              (Gt322*gtu22 + 2*(Gt321*gtu12 + Gt331*gtu13 + Gt332*gtu23) + Gt333*gtu33))*PDstandard4th3phi + 
-          PDstandard4th2phi*(Gt233 + gt33L*(Gt211*gtu11 + Gt222*gtu22 + 2*(Gt221*gtu12 + Gt231*gtu13 + Gt232*gtu23) + 
-                Gt233*gtu33 - 4*gtu23*PDstandard4th3phi)) + 
-          PDstandard4th1phi*(Gt133 + gt33L*(Gt111*gtu11 + Gt122*gtu22 + 2*(Gt121*gtu12 + Gt131*gtu13 + Gt132*gtu23) + 
-                Gt133*gtu33 - 4*(gtu12*PDstandard4th2phi + gtu13*PDstandard4th3phi))) + 2*SQR(PDstandard4th3phi) + 
-          gt33L*(-(gtu11*PDstandard4th11phi) - 2*gtu12*PDstandard4th12phi - 2*gtu13*PDstandard4th13phi - 
-             gtu22*PDstandard4th22phi - 2*gtu23*PDstandard4th23phi - gtu33*PDstandard4th33phi + 
-             Gt311*gtu11*PDstandard4th3phi - 2*gtu11*SQR(PDstandard4th1phi) - 2*gtu22*SQR(PDstandard4th2phi) - 
-             2*gtu33*SQR(PDstandard4th3phi)));
-    
-    R11  =  Rphi11 + Rt11;
-    
-    R21  =  Rphi21 + Rt21;
-    
-    R31  =  Rphi31 + Rt31;
-    
-    R22  =  Rphi22 + Rt22;
-    
-    R32  =  Rphi32 + Rt32;
-    
-    R33  =  Rphi33 + Rt33;
-    
-    trR  =  gu11*R11 + gu22*R22 + 2*(gu12*R21 + gu13*R31 + gu23*R32) + gu33*R33;
-    
-    K11  =  At11L*e4phi + g11*kthird*trKL;
-    
-    K21  =  At21L*e4phi + g21*kthird*trKL;
-    
-    K31  =  At31L*e4phi + g31*kthird*trKL;
-    
-    K22  =  At22L*e4phi + g22*kthird*trKL;
-    
-    K32  =  At32L*e4phi + g32*kthird*trKL;
-    
-    K33  =  At33L*e4phi + g33*kthird*trKL;
-    
-    Km11  =  gu11*K11 + gu12*K21 + gu13*K31;
-    
-    Km21  =  gu12*K11 + gu22*K21 + gu23*K31;
-    
-    Km31  =  gu13*K11 + gu23*K21 + gu33*K31;
-    
-    Km12  =  gu11*K21 + gu12*K22 + gu13*K32;
-    
-    Km22  =  gu12*K21 + gu22*K22 + gu23*K32;
-    
-    Km32  =  gu13*K21 + gu23*K22 + gu33*K32;
-    
-    Km13  =  gu11*K31 + gu12*K32 + gu13*K33;
-    
-    Km23  =  gu12*K31 + gu22*K32 + gu23*K33;
-    
-    Km33  =  gu13*K31 + gu23*K32 + gu33*K33;
-    
-    HL  =  -2*(Km12*Km21 + Km13*Km31 + Km23*Km32) + trR - SQR(Km11) - SQR(Km22) - SQR(Km33) + SQR(trKL);
-    
-    gK112  =  e4phi*(-2*(At11L*G121 + At21L*G221 + At31L*G321) + PDstandard4th2At11 + 4*At11L*PDstandard4th2phi) + 
-        g11*kthird*PDstandard4th2trK;
-    
-    gK113  =  e4phi*(-2*(At11L*G131 + At21L*G231 + At31L*G331) + PDstandard4th3At11 + 4*At11L*PDstandard4th3phi) + 
-        g11*kthird*PDstandard4th3trK;
-    
-    gK211  =  e4phi*(-(At11L*G121) - At22L*G211 - At21L*(G111 + G221) - At32L*G311 - At31L*G321 + PDstandard4th1At21 + 
-           4*At21L*PDstandard4th1phi) + g21*kthird*PDstandard4th1trK;
-    
-    gK212  =  e4phi*(-(At11L*G122) - At22L*G221 - At21L*(G121 + G222) - At32L*G321 - At31L*G322 + PDstandard4th2At21 + 
-           4*At21L*PDstandard4th2phi) + g21*kthird*PDstandard4th2trK;
-    
-    gK213  =  e4phi*(-(At11L*G132) - At22L*G231 - At21L*(G131 + G232) - At32L*G331 - At31L*G332 + PDstandard4th3At21 + 
-           4*At21L*PDstandard4th3phi) + g21*kthird*PDstandard4th3trK;
-    
-    gK311  =  e4phi*(-(At11L*G131) - At32L*G211 - At21L*G231 - At33L*G311 - At31L*(G111 + G331) + PDstandard4th1At31 + 
-           4*At31L*PDstandard4th1phi) + g31*kthird*PDstandard4th1trK;
-    
-    gK312  =  e4phi*(-(At11L*G132) - At32L*G221 - At21L*G232 - At33L*G321 - At31L*(G121 + G332) + PDstandard4th2At31 + 
-           4*At31L*PDstandard4th2phi) + g31*kthird*PDstandard4th2trK;
-    
-    gK313  =  e4phi*(-(At11L*G133) - At32L*G231 - At21L*G233 - At33L*G331 - At31L*(G131 + G333) + PDstandard4th3At31 + 
-           4*At31L*PDstandard4th3phi) + g31*kthird*PDstandard4th3trK;
-    
-    gK221  =  e4phi*(-2*(At21L*G121 + At22L*G221 + At32L*G321) + PDstandard4th1At22 + 4*At22L*PDstandard4th1phi) + 
-        g22*kthird*PDstandard4th1trK;
-    
-    gK223  =  e4phi*(-2*(At21L*G132 + At22L*G232 + At32L*G332) + PDstandard4th3At22 + 4*At22L*PDstandard4th3phi) + 
-        g22*kthird*PDstandard4th3trK;
-    
-    gK321  =  e4phi*(-(At31L*G121) - At21L*G131 - At32L*G221 - At22L*G231 - At33L*G321 - At32L*G331 + PDstandard4th1At32 + 
-           4*At32L*PDstandard4th1phi) + g32*kthird*PDstandard4th1trK;
-    
-    gK322  =  e4phi*(-(At31L*G122) - At21L*G132 - At32L*G222 - At22L*G232 - At33L*G322 - At32L*G332 + PDstandard4th2At32 + 
-           4*At32L*PDstandard4th2phi) + g32*kthird*PDstandard4th2trK;
-    
-    gK323  =  e4phi*(-(At31L*G132) - At21L*G133 - At32L*G232 - At22L*G233 - At33L*G332 - At32L*G333 + PDstandard4th3At32 + 
-           4*At32L*PDstandard4th3phi) + g32*kthird*PDstandard4th3trK;
-    
-    gK331  =  e4phi*(-2*(At31L*G131 + At32L*G231 + At33L*G331) + PDstandard4th1At33 + 4*At33L*PDstandard4th1phi) + 
-        g33*kthird*PDstandard4th1trK;
-    
-    gK332  =  e4phi*(-2*(At31L*G132 + At32L*G232 + At33L*G332) + PDstandard4th2At33 + 4*At33L*PDstandard4th2phi) + 
-        g33*kthird*PDstandard4th2trK;
-    
-    M1L  =  (gK112 - gK211)*gu12 + (gK113 - gK311)*gu13 + (gK212 - gK221)*gu22 + (gK213 + gK312 - 2*gK321)*gu23 + 
-        (gK313 - gK331)*gu33;
-    
-    M2L  =  (-gK112 + gK211)*gu11 + (-gK212 + gK221)*gu12 + (gK213 - 2*gK312 + gK321)*gu13 + (gK223 - gK322)*gu23 + 
-        (gK323 - gK332)*gu33;
-    
-    M3L  =  (-gK113 + gK311)*gu11 + (-2*gK213 + gK312 + gK321)*gu12 + (-gK313 + gK331)*gu13 + (-gK223 + gK322)*gu22 + 
-        (-gK323 + gK332)*gu23;
-    
-    cSL  =  Log(detgt);
-    
-    cXt1L  =  Gt111*gtu11 + Gt122*gtu22 + 2*(Gt121*gtu12 + Gt131*gtu13 + Gt132*gtu23) + Gt133*gtu33 - Xt1L;
-    
-    cXt2L  =  Gt211*gtu11 + Gt222*gtu22 + 2*(Gt221*gtu12 + Gt231*gtu13 + Gt232*gtu23) + Gt233*gtu33 - Xt2L;
-    
-    cXt3L  =  Gt311*gtu11 + Gt322*gtu22 + 2*(Gt321*gtu12 + Gt331*gtu13 + Gt332*gtu23) + Gt333*gtu33 - Xt3L;
-    
-    cAL  =  At11L*gtu11 + At22L*gtu22 + 2*(At21L*gtu12 + At31L*gtu13 + At32L*gtu23) + At33L*gtu33;
-    
-    
-    /* Copy local copies back to grid functions */
-    cA[index] = cAL;
-    cS[index] = cSL;
-    cXt1[index] = cXt1L;
-    cXt2[index] = cXt2L;
-    cXt3[index] = cXt3L;
-    H[index] = HL;
-    M1[index] = M1L;
-    M2[index] = M2L;
-    M3[index] = M3L;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_BSSN_constraints(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverInterior(cctkGH, &ML_BSSN_constraints_Body);
-}
diff --git a/m/ML_BSSN/src/ML_BSSN_convertFromADMBase.c b/m/ML_BSSN/src/ML_BSSN_convertFromADMBase.c
deleted file mode 100644
index 24c57f9..0000000
--- a/m/ML_BSSN/src/ML_BSSN_convertFromADMBase.c
+++ /dev/null
@@ -1,295 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_BSSN_convertFromADMBase_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_BSSN_convertFromADMBase_Body");
-  }
-  
-  if (cctk_iteration % ML_BSSN_convertFromADMBase_calc_every != ML_BSSN_convertFromADMBase_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    CCTK_REAL detg = INITVALUE;
-    CCTK_REAL em4phi = INITVALUE;
-    CCTK_REAL g11 = INITVALUE, g21 = INITVALUE, g22 = INITVALUE, g31 = INITVALUE, g32 = INITVALUE, g33 = INITVALUE;
-    CCTK_REAL gu11 = INITVALUE, gu12 = INITVALUE, gu13 = INITVALUE, gu22 = INITVALUE, gu23 = INITVALUE, gu33 = INITVALUE;
-    CCTK_REAL K11 = INITVALUE, K21 = INITVALUE, K22 = INITVALUE, K31 = INITVALUE, K32 = INITVALUE, K33 = INITVALUE;
-    CCTK_REAL Km11 = INITVALUE, Km22 = INITVALUE, Km33 = INITVALUE;
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL alpL = INITVALUE;
-    CCTK_REAL alphaL = INITVALUE;
-    CCTK_REAL At11L = INITVALUE, At21L = INITVALUE, At22L = INITVALUE, At31L = INITVALUE, At32L = INITVALUE, At33L = INITVALUE;
-    CCTK_REAL beta1L = INITVALUE, beta2L = INITVALUE, beta3L = INITVALUE;
-    CCTK_REAL betaxL = INITVALUE;
-    CCTK_REAL betayL = INITVALUE;
-    CCTK_REAL betazL = INITVALUE;
-    CCTK_REAL dtalpL = INITVALUE;
-    CCTK_REAL dtalphaL = INITVALUE;
-    CCTK_REAL dtbeta1L = INITVALUE, dtbeta2L = INITVALUE, dtbeta3L = INITVALUE;
-    CCTK_REAL dtbetaxL = INITVALUE;
-    CCTK_REAL dtbetayL = INITVALUE;
-    CCTK_REAL dtbetazL = INITVALUE;
-    CCTK_REAL gt11L = INITVALUE, gt21L = INITVALUE, gt22L = INITVALUE, gt31L = INITVALUE, gt32L = INITVALUE, gt33L = INITVALUE;
-    CCTK_REAL gxxL = INITVALUE;
-    CCTK_REAL gxyL = INITVALUE;
-    CCTK_REAL gxzL = INITVALUE;
-    CCTK_REAL gyyL = INITVALUE;
-    CCTK_REAL gyzL = INITVALUE;
-    CCTK_REAL gzzL = INITVALUE;
-    CCTK_REAL kxxL = INITVALUE;
-    CCTK_REAL kxyL = INITVALUE;
-    CCTK_REAL kxzL = INITVALUE;
-    CCTK_REAL kyyL = INITVALUE;
-    CCTK_REAL kyzL = INITVALUE;
-    CCTK_REAL kzzL = INITVALUE;
-    CCTK_REAL phiL = INITVALUE;
-    CCTK_REAL trKL = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    
-    /* Assign local copies of grid functions */
-    alpL = alp[index];
-    betaxL = betax[index];
-    betayL = betay[index];
-    betazL = betaz[index];
-    dtalpL = dtalp[index];
-    dtbetaxL = dtbetax[index];
-    dtbetayL = dtbetay[index];
-    dtbetazL = dtbetaz[index];
-    gxxL = gxx[index];
-    gxyL = gxy[index];
-    gxzL = gxz[index];
-    gyyL = gyy[index];
-    gyzL = gyz[index];
-    gzzL = gzz[index];
-    kxxL = kxx[index];
-    kxyL = kxy[index];
-    kxzL = kxz[index];
-    kyyL = kyy[index];
-    kyzL = kyz[index];
-    kzzL = kzz[index];
-    trKL = trK[index];
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    g11  =  gxxL;
-    
-    g21  =  gxyL;
-    
-    g31  =  gxzL;
-    
-    g22  =  gyyL;
-    
-    g32  =  gyzL;
-    
-    g33  =  gzzL;
-    
-    detg  =  2*g21*g31*g32 + g33*(g11*g22 - SQR(g21)) - g22*SQR(g31) - g11*SQR(g32);
-    
-    gu11  =  INV(detg)*(g22*g33 - SQR(g32));
-    
-    gu12  =  (g31*g32 - g21*g33)*INV(detg);
-    
-    gu13  =  (-(g22*g31) + g21*g32)*INV(detg);
-    
-    gu22  =  INV(detg)*(g11*g33 - SQR(g31));
-    
-    gu23  =  (g21*g31 - g11*g32)*INV(detg);
-    
-    gu33  =  INV(detg)*(g11*g22 - SQR(g21));
-    
-    em4phi  =  pow(detg,-3);
-    
-    phiL  =  Log(detg)/12.;
-    
-    gt11L  =  em4phi*g11;
-    
-    gt21L  =  em4phi*g21;
-    
-    gt31L  =  em4phi*g31;
-    
-    gt22L  =  em4phi*g22;
-    
-    gt32L  =  em4phi*g32;
-    
-    gt33L  =  em4phi*g33;
-    
-    K11  =  kxxL;
-    
-    K21  =  kxyL;
-    
-    K31  =  kxzL;
-    
-    K22  =  kyyL;
-    
-    K32  =  kyzL;
-    
-    K33  =  kzzL;
-    
-    Km11  =  gu11*K11 + gu12*K21 + gu13*K31;
-    
-    Km22  =  gu12*K21 + gu22*K22 + gu23*K32;
-    
-    Km33  =  gu13*K31 + gu23*K32 + gu33*K33;
-    
-    trKL  =  Km11 + Km22 + Km33;
-    
-    At11L  =  em4phi*(K11 - g11*kthird*trKL);
-    
-    At21L  =  em4phi*(K21 - g21*kthird*trKL);
-    
-    At31L  =  em4phi*(K31 - g31*kthird*trKL);
-    
-    At22L  =  em4phi*(K22 - g22*kthird*trKL);
-    
-    At32L  =  em4phi*(K32 - g32*kthird*trKL);
-    
-    At33L  =  em4phi*(K33 - g33*kthird*trKL);
-    
-    alphaL  =  alpL;
-    
-    dtalphaL  =  dtalpL;
-    
-    beta1L  =  betaxL;
-    
-    beta2L  =  betayL;
-    
-    beta3L  =  betazL;
-    
-    dtbeta1L  =  dtbetaxL;
-    
-    dtbeta2L  =  dtbetayL;
-    
-    dtbeta3L  =  dtbetazL;
-    
-    
-    /* Copy local copies back to grid functions */
-    alpha[index] = alphaL;
-    At11[index] = At11L;
-    At21[index] = At21L;
-    At22[index] = At22L;
-    At31[index] = At31L;
-    At32[index] = At32L;
-    At33[index] = At33L;
-    beta1[index] = beta1L;
-    beta2[index] = beta2L;
-    beta3[index] = beta3L;
-    dtalpha[index] = dtalphaL;
-    dtbeta1[index] = dtbeta1L;
-    dtbeta2[index] = dtbeta2L;
-    dtbeta3[index] = dtbeta3L;
-    gt11[index] = gt11L;
-    gt21[index] = gt21L;
-    gt22[index] = gt22L;
-    gt31[index] = gt31L;
-    gt32[index] = gt32L;
-    gt33[index] = gt33L;
-    phi[index] = phiL;
-    trK[index] = trKL;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_BSSN_convertFromADMBase(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverEverything(cctkGH, &ML_BSSN_convertFromADMBase_Body);
-}
diff --git a/m/ML_BSSN/src/ML_BSSN_convertFromADMBaseGamma.c b/m/ML_BSSN/src/ML_BSSN_convertFromADMBaseGamma.c
deleted file mode 100644
index 0dc3bfe..0000000
--- a/m/ML_BSSN/src/ML_BSSN_convertFromADMBaseGamma.c
+++ /dev/null
@@ -1,254 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_BSSN_convertFromADMBaseGamma_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_BSSN_convertFromADMBaseGamma_Body");
-  }
-  
-  if (cctk_iteration % ML_BSSN_convertFromADMBaseGamma_calc_every != ML_BSSN_convertFromADMBaseGamma_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    CCTK_REAL detgt = INITVALUE;
-    CCTK_REAL Gt111 = INITVALUE, Gt121 = INITVALUE, Gt122 = INITVALUE, Gt131 = INITVALUE, Gt132 = INITVALUE, Gt133 = INITVALUE;
-    CCTK_REAL Gt211 = INITVALUE, Gt221 = INITVALUE, Gt222 = INITVALUE, Gt231 = INITVALUE, Gt232 = INITVALUE, Gt233 = INITVALUE;
-    CCTK_REAL Gt311 = INITVALUE, Gt321 = INITVALUE, Gt322 = INITVALUE, Gt331 = INITVALUE, Gt332 = INITVALUE, Gt333 = INITVALUE;
-    CCTK_REAL gtu11 = INITVALUE, gtu12 = INITVALUE, gtu13 = INITVALUE, gtu22 = INITVALUE, gtu23 = INITVALUE, gtu33 = INITVALUE;
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL gt11L = INITVALUE, gt21L = INITVALUE, gt22L = INITVALUE, gt31L = INITVALUE, gt32L = INITVALUE, gt33L = INITVALUE;
-    CCTK_REAL Xt1L = INITVALUE, Xt2L = INITVALUE, Xt3L = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    CCTK_REAL PDstandard4th1gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt11 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt21 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt22 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt31 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt32 = INITVALUE;
-    CCTK_REAL PDstandard4th1gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th2gt33 = INITVALUE;
-    CCTK_REAL PDstandard4th3gt33 = INITVALUE;
-    
-    /* Assign local copies of grid functions */
-    gt11L = gt11[index];
-    gt21L = gt21[index];
-    gt22L = gt22[index];
-    gt31L = gt31[index];
-    gt32L = gt32[index];
-    gt33L = gt33[index];
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    PDstandard4th1gt11 = PDstandard4th1(gt11, i, j, k);
-    PDstandard4th2gt11 = PDstandard4th2(gt11, i, j, k);
-    PDstandard4th3gt11 = PDstandard4th3(gt11, i, j, k);
-    PDstandard4th1gt21 = PDstandard4th1(gt21, i, j, k);
-    PDstandard4th2gt21 = PDstandard4th2(gt21, i, j, k);
-    PDstandard4th3gt21 = PDstandard4th3(gt21, i, j, k);
-    PDstandard4th1gt22 = PDstandard4th1(gt22, i, j, k);
-    PDstandard4th2gt22 = PDstandard4th2(gt22, i, j, k);
-    PDstandard4th3gt22 = PDstandard4th3(gt22, i, j, k);
-    PDstandard4th1gt31 = PDstandard4th1(gt31, i, j, k);
-    PDstandard4th2gt31 = PDstandard4th2(gt31, i, j, k);
-    PDstandard4th3gt31 = PDstandard4th3(gt31, i, j, k);
-    PDstandard4th1gt32 = PDstandard4th1(gt32, i, j, k);
-    PDstandard4th2gt32 = PDstandard4th2(gt32, i, j, k);
-    PDstandard4th3gt32 = PDstandard4th3(gt32, i, j, k);
-    PDstandard4th1gt33 = PDstandard4th1(gt33, i, j, k);
-    PDstandard4th2gt33 = PDstandard4th2(gt33, i, j, k);
-    PDstandard4th3gt33 = PDstandard4th3(gt33, i, j, k);
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    detgt  =  2*gt21L*gt31L*gt32L + gt33L*(gt11L*gt22L - SQR(gt21L)) - gt22L*SQR(gt31L) - gt11L*SQR(gt32L);
-    
-    gtu11  =  INV(detgt)*(gt22L*gt33L - SQR(gt32L));
-    
-    gtu12  =  (gt31L*gt32L - gt21L*gt33L)*INV(detgt);
-    
-    gtu13  =  (-(gt22L*gt31L) + gt21L*gt32L)*INV(detgt);
-    
-    gtu22  =  INV(detgt)*(gt11L*gt33L - SQR(gt31L));
-    
-    gtu23  =  (gt21L*gt31L - gt11L*gt32L)*INV(detgt);
-    
-    gtu33  =  INV(detgt)*(gt11L*gt22L - SQR(gt21L));
-    
-    Gt111  =  khalf*(gtu11*PDstandard4th1gt11 + 2*(gtu12*PDstandard4th1gt21 + gtu13*PDstandard4th1gt31) - 
-          gtu12*PDstandard4th2gt11 - gtu13*PDstandard4th3gt11);
-    
-    Gt211  =  khalf*(gtu12*PDstandard4th1gt11 + 2*(gtu22*PDstandard4th1gt21 + gtu23*PDstandard4th1gt31) - 
-          gtu22*PDstandard4th2gt11 - gtu23*PDstandard4th3gt11);
-    
-    Gt311  =  khalf*(gtu13*PDstandard4th1gt11 + 2*(gtu23*PDstandard4th1gt21 + gtu33*PDstandard4th1gt31) - 
-          gtu23*PDstandard4th2gt11 - gtu33*PDstandard4th3gt11);
-    
-    Gt121  =  khalf*(gtu12*PDstandard4th1gt22 + gtu11*PDstandard4th2gt11 + 
-          gtu13*(PDstandard4th1gt32 + PDstandard4th2gt31 - PDstandard4th3gt21));
-    
-    Gt221  =  khalf*(gtu22*PDstandard4th1gt22 + gtu12*PDstandard4th2gt11 + 
-          gtu23*(PDstandard4th1gt32 + PDstandard4th2gt31 - PDstandard4th3gt21));
-    
-    Gt321  =  khalf*(gtu23*PDstandard4th1gt22 + gtu13*PDstandard4th2gt11 + 
-          gtu33*(PDstandard4th1gt32 + PDstandard4th2gt31 - PDstandard4th3gt21));
-    
-    Gt131  =  khalf*(gtu13*PDstandard4th1gt33 + gtu11*PDstandard4th3gt11 + 
-          gtu12*(PDstandard4th1gt32 - PDstandard4th2gt31 + PDstandard4th3gt21));
-    
-    Gt231  =  khalf*(gtu23*PDstandard4th1gt33 + gtu12*PDstandard4th3gt11 + 
-          gtu22*(PDstandard4th1gt32 - PDstandard4th2gt31 + PDstandard4th3gt21));
-    
-    Gt331  =  khalf*(gtu33*PDstandard4th1gt33 + gtu13*PDstandard4th3gt11 + 
-          gtu23*(PDstandard4th1gt32 - PDstandard4th2gt31 + PDstandard4th3gt21));
-    
-    Gt122  =  khalf*(gtu11*(-PDstandard4th1gt22 + 2*PDstandard4th2gt21) + gtu12*PDstandard4th2gt22 + 
-          gtu13*(2*PDstandard4th2gt32 - PDstandard4th3gt22));
-    
-    Gt222  =  khalf*(gtu12*(-PDstandard4th1gt22 + 2*PDstandard4th2gt21) + gtu22*PDstandard4th2gt22 + 
-          gtu23*(2*PDstandard4th2gt32 - PDstandard4th3gt22));
-    
-    Gt322  =  khalf*(gtu13*(-PDstandard4th1gt22 + 2*PDstandard4th2gt21) + gtu23*PDstandard4th2gt22 + 
-          gtu33*(2*PDstandard4th2gt32 - PDstandard4th3gt22));
-    
-    Gt132  =  khalf*(gtu13*PDstandard4th2gt33 + gtu11*(-PDstandard4th1gt32 + PDstandard4th2gt31 + PDstandard4th3gt21) + 
-          gtu12*PDstandard4th3gt22);
-    
-    Gt232  =  khalf*(gtu23*PDstandard4th2gt33 + gtu12*(-PDstandard4th1gt32 + PDstandard4th2gt31 + PDstandard4th3gt21) + 
-          gtu22*PDstandard4th3gt22);
-    
-    Gt332  =  khalf*(gtu33*PDstandard4th2gt33 + gtu13*(-PDstandard4th1gt32 + PDstandard4th2gt31 + PDstandard4th3gt21) + 
-          gtu23*PDstandard4th3gt22);
-    
-    Gt133  =  khalf*(-(gtu11*PDstandard4th1gt33) - gtu12*PDstandard4th2gt33 + 2*gtu11*PDstandard4th3gt31 + 
-          2*gtu12*PDstandard4th3gt32 + gtu13*PDstandard4th3gt33);
-    
-    Gt233  =  khalf*(-(gtu12*PDstandard4th1gt33) - gtu22*PDstandard4th2gt33 + 2*gtu12*PDstandard4th3gt31 + 
-          2*gtu22*PDstandard4th3gt32 + gtu23*PDstandard4th3gt33);
-    
-    Gt333  =  khalf*(-(gtu13*PDstandard4th1gt33) - gtu23*PDstandard4th2gt33 + 2*gtu13*PDstandard4th3gt31 + 
-          2*gtu23*PDstandard4th3gt32 + gtu33*PDstandard4th3gt33);
-    
-    Xt1L  =  Gt111*gtu11 + Gt122*gtu22 + 2*(Gt121*gtu12 + Gt131*gtu13 + Gt132*gtu23) + Gt133*gtu33;
-    
-    Xt2L  =  Gt211*gtu11 + Gt222*gtu22 + 2*(Gt221*gtu12 + Gt231*gtu13 + Gt232*gtu23) + Gt233*gtu33;
-    
-    Xt3L  =  Gt311*gtu11 + Gt322*gtu22 + 2*(Gt321*gtu12 + Gt331*gtu13 + Gt332*gtu23) + Gt333*gtu33;
-    
-    
-    /* Copy local copies back to grid functions */
-    Xt1[index] = Xt1L;
-    Xt2[index] = Xt2L;
-    Xt3[index] = Xt3L;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_BSSN_convertFromADMBaseGamma(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverInterior(cctkGH, &ML_BSSN_convertFromADMBaseGamma_Body);
-}
diff --git a/m/ML_BSSN/src/ML_BSSN_convertToADMBase.c b/m/ML_BSSN/src/ML_BSSN_convertToADMBase.c
deleted file mode 100644
index 03e3004..0000000
--- a/m/ML_BSSN/src/ML_BSSN_convertToADMBase.c
+++ /dev/null
@@ -1,267 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_BSSN_convertToADMBase_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_BSSN_convertToADMBase_Body");
-  }
-  
-  if (cctk_iteration % ML_BSSN_convertToADMBase_calc_every != ML_BSSN_convertToADMBase_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    CCTK_REAL e4phi = INITVALUE;
-    CCTK_REAL g11 = INITVALUE, g21 = INITVALUE, g22 = INITVALUE, g31 = INITVALUE, g32 = INITVALUE, g33 = INITVALUE;
-    CCTK_REAL K11 = INITVALUE, K21 = INITVALUE, K22 = INITVALUE, K31 = INITVALUE, K32 = INITVALUE, K33 = INITVALUE;
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL alpL = INITVALUE;
-    CCTK_REAL alphaL = INITVALUE;
-    CCTK_REAL At11L = INITVALUE, At21L = INITVALUE, At22L = INITVALUE, At31L = INITVALUE, At32L = INITVALUE, At33L = INITVALUE;
-    CCTK_REAL beta1L = INITVALUE, beta2L = INITVALUE, beta3L = INITVALUE;
-    CCTK_REAL betaxL = INITVALUE;
-    CCTK_REAL betayL = INITVALUE;
-    CCTK_REAL betazL = INITVALUE;
-    CCTK_REAL dtalpL = INITVALUE;
-    CCTK_REAL dtalphaL = INITVALUE;
-    CCTK_REAL dtbeta1L = INITVALUE, dtbeta2L = INITVALUE, dtbeta3L = INITVALUE;
-    CCTK_REAL dtbetaxL = INITVALUE;
-    CCTK_REAL dtbetayL = INITVALUE;
-    CCTK_REAL dtbetazL = INITVALUE;
-    CCTK_REAL gt11L = INITVALUE, gt21L = INITVALUE, gt22L = INITVALUE, gt31L = INITVALUE, gt32L = INITVALUE, gt33L = INITVALUE;
-    CCTK_REAL gxxL = INITVALUE;
-    CCTK_REAL gxyL = INITVALUE;
-    CCTK_REAL gxzL = INITVALUE;
-    CCTK_REAL gyyL = INITVALUE;
-    CCTK_REAL gyzL = INITVALUE;
-    CCTK_REAL gzzL = INITVALUE;
-    CCTK_REAL kxxL = INITVALUE;
-    CCTK_REAL kxyL = INITVALUE;
-    CCTK_REAL kxzL = INITVALUE;
-    CCTK_REAL kyyL = INITVALUE;
-    CCTK_REAL kyzL = INITVALUE;
-    CCTK_REAL kzzL = INITVALUE;
-    CCTK_REAL phiL = INITVALUE;
-    CCTK_REAL trKL = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    
-    /* Assign local copies of grid functions */
-    alphaL = alpha[index];
-    At11L = At11[index];
-    At21L = At21[index];
-    At22L = At22[index];
-    At31L = At31[index];
-    At32L = At32[index];
-    At33L = At33[index];
-    beta1L = beta1[index];
-    beta2L = beta2[index];
-    beta3L = beta3[index];
-    dtalphaL = dtalpha[index];
-    dtbeta1L = dtbeta1[index];
-    dtbeta2L = dtbeta2[index];
-    dtbeta3L = dtbeta3[index];
-    gt11L = gt11[index];
-    gt21L = gt21[index];
-    gt22L = gt22[index];
-    gt31L = gt31[index];
-    gt32L = gt32[index];
-    gt33L = gt33[index];
-    phiL = phi[index];
-    trKL = trK[index];
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    e4phi  =  exp(4*phiL);
-    
-    g11  =  e4phi*gt11L;
-    
-    g21  =  e4phi*gt21L;
-    
-    g31  =  e4phi*gt31L;
-    
-    g22  =  e4phi*gt22L;
-    
-    g32  =  e4phi*gt32L;
-    
-    g33  =  e4phi*gt33L;
-    
-    gxxL  =  g11;
-    
-    gxyL  =  g21;
-    
-    gxzL  =  g31;
-    
-    gyyL  =  g22;
-    
-    gyzL  =  g32;
-    
-    gzzL  =  g33;
-    
-    K11  =  At11L*e4phi + g11*kthird*trKL;
-    
-    K21  =  At21L*e4phi + g21*kthird*trKL;
-    
-    K31  =  At31L*e4phi + g31*kthird*trKL;
-    
-    K22  =  At22L*e4phi + g22*kthird*trKL;
-    
-    K32  =  At32L*e4phi + g32*kthird*trKL;
-    
-    K33  =  At33L*e4phi + g33*kthird*trKL;
-    
-    kxxL  =  K11;
-    
-    kxyL  =  K21;
-    
-    kxzL  =  K31;
-    
-    kyyL  =  K22;
-    
-    kyzL  =  K32;
-    
-    kzzL  =  K33;
-    
-    alpL  =  alphaL;
-    
-    dtalpL  =  dtalphaL;
-    
-    betaxL  =  beta1L;
-    
-    betayL  =  beta2L;
-    
-    betazL  =  beta3L;
-    
-    dtbetaxL  =  dtbeta1L;
-    
-    dtbetayL  =  dtbeta2L;
-    
-    dtbetazL  =  dtbeta3L;
-    
-    
-    /* Copy local copies back to grid functions */
-    alp[index] = alpL;
-    betax[index] = betaxL;
-    betay[index] = betayL;
-    betaz[index] = betazL;
-    dtalp[index] = dtalpL;
-    dtbetax[index] = dtbetaxL;
-    dtbetay[index] = dtbetayL;
-    dtbetaz[index] = dtbetazL;
-    gxx[index] = gxxL;
-    gxy[index] = gxyL;
-    gxz[index] = gxzL;
-    gyy[index] = gyyL;
-    gyz[index] = gyzL;
-    gzz[index] = gzzL;
-    kxx[index] = kxxL;
-    kxy[index] = kxyL;
-    kxz[index] = kxzL;
-    kyy[index] = kyyL;
-    kyz[index] = kyzL;
-    kzz[index] = kzzL;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_BSSN_convertToADMBase(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverEverything(cctkGH, &ML_BSSN_convertToADMBase_Body);
-}
diff --git a/m/ML_BSSN/src/ML_BSSN_enforce.c b/m/ML_BSSN/src/ML_BSSN_enforce.c
deleted file mode 100644
index 9442ff9..0000000
--- a/m/ML_BSSN/src/ML_BSSN_enforce.c
+++ /dev/null
@@ -1,179 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#define KRANC_C
-
-#include <math.h>
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "GenericFD.h"
-#include "Differencing.h"
-#include "loopcontrol.h"
-
-/* Define macros used in calculations */
-#define INITVALUE  (42)
-#define INV(x) ((1.0) / (x))
-#define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
-#define QAD(x) ((x) * (x) * (x) * (x))
-
-void ML_BSSN_enforce_Body(cGH *cctkGH, CCTK_INT dir, CCTK_INT face, CCTK_REAL normal[3], CCTK_REAL tangentA[3], CCTK_REAL tangentB[3], CCTK_INT min[3], CCTK_INT max[3], CCTK_INT n_subblock_gfs, CCTK_REAL *subblock_gfs[])
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* Declare finite differencing variables */
-  CCTK_REAL dx = INITVALUE, dy = INITVALUE, dz = INITVALUE;
-  CCTK_REAL dxi = INITVALUE, dyi = INITVALUE, dzi = INITVALUE;
-  CCTK_REAL khalf = INITVALUE, kthird = INITVALUE, ktwothird = INITVALUE, kfourthird = INITVALUE, keightthird = INITVALUE;
-  CCTK_REAL hdxi = INITVALUE, hdyi = INITVALUE, hdzi = INITVALUE;
-  
-  
-  /* Declare predefined quantities */
-  CCTK_REAL p1o12dx = INITVALUE;
-  CCTK_REAL p1o12dy = INITVALUE;
-  CCTK_REAL p1o12dz = INITVALUE;
-  CCTK_REAL p1o144dxdy = INITVALUE;
-  CCTK_REAL p1o144dxdz = INITVALUE;
-  CCTK_REAL p1o144dydz = INITVALUE;
-  CCTK_REAL pm1o12dx2 = INITVALUE;
-  CCTK_REAL pm1o12dy2 = INITVALUE;
-  CCTK_REAL pm1o12dz2 = INITVALUE;
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering ML_BSSN_enforce_Body");
-  }
-  
-  if (cctk_iteration % ML_BSSN_enforce_calc_every != ML_BSSN_enforce_calc_offset)
-  {
-    return;
-  }
-  
-  /* Include user-supplied include files */
-  
-  /* Initialise finite differencing variables */
-  dx = CCTK_DELTA_SPACE(0);
-  dy = CCTK_DELTA_SPACE(1);
-  dz = CCTK_DELTA_SPACE(2);
-  dxi = 1.0 / dx;
-  dyi = 1.0 / dy;
-  dzi = 1.0 / dz;
-  khalf = 0.5;
-  kthird = 1/3.0;
-  ktwothird = 2.0/3.0;
-  kfourthird = 4.0/3.0;
-  keightthird = 8.0/3.0;
-  hdxi = 0.5 * dxi;
-  hdyi = 0.5 * dyi;
-  hdzi = 0.5 * dzi;
-  
-  /* Initialize predefined quantities */
-  p1o12dx = INV(dx)/12.;
-  p1o12dy = INV(dy)/12.;
-  p1o12dz = INV(dz)/12.;
-  p1o144dxdy = (INV(dx)*INV(dy))/144.;
-  p1o144dxdz = (INV(dx)*INV(dz))/144.;
-  p1o144dydz = (INV(dy)*INV(dz))/144.;
-  pm1o12dx2 = -pow(dx,-2)/12.;
-  pm1o12dy2 = -pow(dy,-2)/12.;
-  pm1o12dz2 = -pow(dz,-2)/12.;
-  
-  /* Loop over the grid points */
-  LC_LOOP3 (somename,
-            i,j,k, min[0],min[1],min[2], max[0],max[1],max[2],
-            cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
-  {
-    int index = INITVALUE;
-    int subblock_index = INITVALUE;
-    index = CCTK_GFINDEX3D(cctkGH,i,j,k);
-    subblock_index = i - min[0] + (max[0] - min[0]) * (j - min[1] + (max[1]-min[1]) * (k - min[2]));
-    
-    /* Declare shorthands */
-    CCTK_REAL detgt = INITVALUE;
-    CCTK_REAL gtu11 = INITVALUE, gtu12 = INITVALUE, gtu13 = INITVALUE, gtu22 = INITVALUE, gtu23 = INITVALUE, gtu33 = INITVALUE;
-    CCTK_REAL trA = INITVALUE;
-    
-    /* Declare local copies of grid functions */
-    CCTK_REAL At11L = INITVALUE, At21L = INITVALUE, At22L = INITVALUE, At31L = INITVALUE, At32L = INITVALUE, At33L = INITVALUE;
-    CCTK_REAL gt11L = INITVALUE, gt21L = INITVALUE, gt22L = INITVALUE, gt31L = INITVALUE, gt32L = INITVALUE, gt33L = INITVALUE;
-    /* Declare precomputed derivatives*/
-    
-    /* Declare derivatives */
-    
-    /* Assign local copies of grid functions */
-    At11L = At11[index];
-    At21L = At21[index];
-    At22L = At22[index];
-    At31L = At31[index];
-    At32L = At32[index];
-    At33L = At33[index];
-    gt11L = gt11[index];
-    gt21L = gt21[index];
-    gt22L = gt22[index];
-    gt31L = gt31[index];
-    gt32L = gt32[index];
-    gt33L = gt33[index];
-    
-    /* Assign local copies of subblock grid functions */
-    
-    /* Include user supplied include files */
-    
-    /* Precompute derivatives (new style) */
-    
-    /* Precompute derivatives (old style) */
-    
-    /* Calculate temporaries and grid functions */
-    detgt  =  2*gt21L*gt31L*gt32L + gt33L*(gt11L*gt22L - SQR(gt21L)) - gt22L*SQR(gt31L) - gt11L*SQR(gt32L);
-    
-    gtu11  =  INV(detgt)*(gt22L*gt33L - SQR(gt32L));
-    
-    gtu12  =  (gt31L*gt32L - gt21L*gt33L)*INV(detgt);
-    
-    gtu13  =  (-(gt22L*gt31L) + gt21L*gt32L)*INV(detgt);
-    
-    gtu22  =  INV(detgt)*(gt11L*gt33L - SQR(gt31L));
-    
-    gtu23  =  (gt21L*gt31L - gt11L*gt32L)*INV(detgt);
-    
-    gtu33  =  INV(detgt)*(gt11L*gt22L - SQR(gt21L));
-    
-    trA  =  At11L*gtu11 + At22L*gtu22 + 2*(At21L*gtu12 + At31L*gtu13 + At32L*gtu23) + At33L*gtu33;
-    
-    At11L  =  At11L - gt11L*kthird*trA;
-    
-    At21L  =  At21L - gt21L*kthird*trA;
-    
-    At31L  =  At31L - gt31L*kthird*trA;
-    
-    At22L  =  At22L - gt22L*kthird*trA;
-    
-    At32L  =  At32L - gt32L*kthird*trA;
-    
-    At33L  =  At33L - gt33L*kthird*trA;
-    
-    
-    /* Copy local copies back to grid functions */
-    At11[index] = At11L;
-    At21[index] = At21L;
-    At22[index] = At22L;
-    At31[index] = At31L;
-    At32[index] = At32L;
-    At33[index] = At33L;
-    
-    /* Copy local copies back to subblock grid functions */
-  }
-  LC_ENDLOOP3 (somename);
-}
-
-void ML_BSSN_enforce(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  GenericFD_LoopOverEverything(cctkGH, &ML_BSSN_enforce_Body);
-}
diff --git a/m/ML_BSSN/src/RegisterMoL.c b/m/ML_BSSN/src/RegisterMoL.c
deleted file mode 100644
index 8154e5f..0000000
--- a/m/ML_BSSN/src/RegisterMoL.c
+++ /dev/null
@@ -1,19 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-
-void ML_BSSN_RegisterVars(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  CCTK_INT ierr = 0;
-  
-  /* Register all the evolved grid functions with MoL */
-  return;
-}
diff --git a/m/ML_BSSN/src/RegisterSymmetries.c b/m/ML_BSSN/src/RegisterSymmetries.c
deleted file mode 100644
index 6ca48f8..0000000
--- a/m/ML_BSSN/src/RegisterSymmetries.c
+++ /dev/null
@@ -1,192 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#include "cctk.h"
-#include "cctk_Arguments.h"
-#include "cctk_Parameters.h"
-#include "Symmetry.h"
-
-void ML_BSSN_RegisterSymmetries(CCTK_ARGUMENTS)
-{
-  DECLARE_CCTK_ARGUMENTS
-  DECLARE_CCTK_PARAMETERS
-  
-  
-  /* array holding symmetry definitions */
-  CCTK_INT sym[3];
-  
-  
-  /* Register symmetries of grid functions */
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cS");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt1");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt2");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cXt3");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::cA");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At11");
-  
-  sym[0] = -1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At21");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At31");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At22");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At32");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::At33");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::dtalpha");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::dtbeta1");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::dtbeta2");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::dtbeta3");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::Xt1");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::Xt2");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::Xt3");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::H");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::alpha");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::phi");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt11");
-  
-  sym[0] = -1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt21");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt31");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt22");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt32");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::gt33");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::M1");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::M2");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::M3");
-  
-  sym[0] = -1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::beta1");
-  
-  sym[0] = 1;
-  sym[1] = -1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::beta2");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = -1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::beta3");
-  
-  sym[0] = 1;
-  sym[1] = 1;
-  sym[2] = 1;
-  SetCartSymVN(cctkGH, sym, "ML_BSSN::trK");
-  
-}
diff --git a/m/ML_BSSN/src/Startup.c b/m/ML_BSSN/src/Startup.c
deleted file mode 100644
index 2bb6a00..0000000
--- a/m/ML_BSSN/src/Startup.c
+++ /dev/null
@@ -1,13 +0,0 @@
-/*  File produced by user eschnett */
-/*  Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007) */
-
-/*  Mathematica script written by Ian Hinder and Sascha Husa */
-
-#include "cctk.h"
-
-int ML_BSSN_Startup(void)
-{
-  const char * banner = "ML_BSSN";
-  CCTK_RegisterBanner(banner);
-  return 0;
-}
diff --git a/m/ML_BSSN/src/make.code.defn b/m/ML_BSSN/src/make.code.defn
deleted file mode 100644
index 3aa081e..0000000
--- a/m/ML_BSSN/src/make.code.defn
+++ /dev/null
@@ -1,6 +0,0 @@
-# File produced by user eschnett
-# Produced with Mathematica Version 6.0 for Mac OS X x86 (32-bit) (April 20, 2007)
-
-# Mathematica script written by Ian Hinder and Sascha Husa
-
-SRCS = Startup.c RegisterMoL.c RegisterSymmetries.c ML_BSSN_Minkowski.c ML_BSSN_convertFromADMBase.c ML_BSSN_convertFromADMBaseGamma.c ML_BSSN_enforce.c ML_BSSN_convertToADMBase.c ML_BSSN_constraints.c Boundaries.c 
diff --git a/m/McLachlan.m b/m/McLachlan.m
index 8762230..559da75 100644
--- a/m/McLachlan.m
+++ b/m/McLachlan.m
@@ -1,5 +1,3 @@
-(* < McLachlan.m /Applications/Mathematica.app/Contents/MacOS/MathKernel | tee McLachlan.out *)
-
 $Path = Join[$Path, {"~/Calpha/Kranc-devel/Tools/CodeGen",
                      "~/Calpha/Kranc-devel/Tools/MathematicaMisc"}];
 
@@ -45,9 +43,17 @@ KD = KroneckerDelta;
 (* Register the tensor quantities with the TensorTools package *)
 Map [DefineTensor,
      {g, K, alpha, beta, H, M, detg, gu, G, R, trR, Km, trK,
-      phi, gt, At, Xt, dtalpha, dtbeta, trA, cXt, cS, cA,
-      e4phi, em4phi, gtu, ddetg, ddetgt, Gt, Rt, Rphi, gK}];
-(* SetTensorAttribute[g, TensorWeight, 0]; *)
+      phi, gt, At, Xt, dtalpha, dtbeta, Atm, Atu, trA, cXt, cS, cA,
+      e4phi, em4phi, ddetg, detgt, gtu, ddetgt, dgtu, ddgtu, Gt, Rt, Rphi, gK}];
+
+(* NOTE: It seems as if Lie[.,.] did not take these tensor weights
+   into account.  Presumably, CD[.,.] and CDt[.,.] don't do this either.  *)
+SetTensorAttribute[phi, TensorWeight, +1/6];
+SetTensorAttribute[gt,  TensorWeight, -2/3];
+SetTensorAttribute[Xt,  TensorWeight, +2/3];
+SetTensorAttribute[At,  TensorWeight, -2/3];
+SetTensorAttribute[cXt, TensorWeight, +2/3];
+SetTensorAttribute[cS,  TensorWeight, +2  ];
 
 Map [AssertSymmetricDecreasing,
      {g[la,lb], K[la,lb], R[la,lb],
@@ -55,8 +61,10 @@ Map [AssertSymmetricDecreasing,
 AssertSymmetricDecreasing [G[ua,lb,lc], lb, lc];
 AssertSymmetricDecreasing [Gt[ua,lb,lc], lb, lc];
 AssertSymmetricDecreasing [gK[la,lb,lc], la, lb];
-Map [AssertSymmetricIncreasing, {gu[ua,ub]}];
-Map [AssertSymmetricIncreasing, {gtu[ua,ub]}];
+Map [AssertSymmetricIncreasing, {gu[ua,ub], gtu[ua,ub], Atu[ua,ub]}];
+AssertSymmetricIncreasing [dgtu[ua,ub,lc], ua, ub];
+AssertSymmetricIncreasing [ddgtu[ua,ub,lc,ld], ua, ub];
+AssertSymmetricDecreasing [ddgtu[ua,ub,lc,ld], lc, ld];
 
 DefineConnection [CD, PD, G];
 DefineConnection [CDt, PD, Gt];
@@ -182,7 +190,7 @@ initialCalcBSSN =
 convertFromADMBaseCalc =
 {
   Name -> "ML_ADM_convertFromADMBase",
-  Schedule -> {"AT initial", "AFTER ADMBase_PostInitial"},
+  Schedule -> {"AT initial AFTER ADMBase_PostInitial"},
   ConditionalOnKeyword -> {"my_initial_data", "ADMBase"},
   Equations -> 
   {
@@ -209,7 +217,7 @@ convertFromADMBaseCalc =
 convertFromADMBaseCalcBSSN =
 {
   Name -> "ML_BSSN_convertFromADMBase",
-  Schedule -> {"AT initial", "AFTER ADMBase_PostInitial"},
+  Schedule -> {"AT initial AFTER ADMBase_PostInitial"},
   ConditionalOnKeyword -> {"my_initial_data", "ADMBase"},
   Shorthands -> {g[la,lb], detg, gu[ua,ub], em4phi, K[la,lb], Km[ua,lb]},
   Equations -> 
@@ -256,13 +264,13 @@ convertFromADMBaseCalcBSSN =
 convertFromADMBaseCalcBSSNGamma =
 {
   Name -> "ML_BSSN_convertFromADMBaseGamma",
-  Schedule -> {"AT initial", "AFTER ML_BSSN_convertFromADMBase"},
+  Schedule -> {"AT initial AFTER ML_BSSN_convertFromADMBase"},
   ConditionalOnKeyword -> {"my_initial_data", "ADMBase"},
   Where -> Interior,
   Shorthands -> {detgt, gtu[ua,ub], Gt[ua,lb,lc]},
   Equations -> 
   {
-    detgt        -> detgtExpr,
+    detgt        -> 1 (* detgtExpr *),
     gtu[ua,ub]   -> 1/detgt detgtExpr MatrixInverse [gt[ua,ub]],
     Gt[ua,lb,lc] -> 1/2 gtu[ua,ud]
                     (PD[gt[lb,ld],lc] + PD[gt[lc,ld],lb] - PD[gt[lb,lc],ld]),
@@ -277,7 +285,7 @@ convertFromADMBaseCalcBSSNGamma =
 convertToADMBaseCalc =
 {
   Name -> "ML_ADM_convertToADMBase",
-  Schedule -> {"IN MoL_PostStep", "AFTER ADM_ApplyBoundConds"},
+  Schedule -> {"IN MoL_PostStep AFTER ADM_ApplyBoundConds"},
   Equations -> 
   {
     gxx     -> g11,
@@ -307,7 +315,7 @@ convertToADMBaseCalc =
 convertToADMBaseCalcBSSN =
 {
   Name -> "ML_BSSN_convertToADMBase",
-  Schedule -> {"IN MoL_PostStep", "AFTER ML_ADM_ApplyBoundConds"},
+  Schedule -> {"IN MoL_PostStep AFTER ML_BSSN_ApplyBoundConds AFTER ML_BSSN_enforce"},
   Shorthands -> {e4phi, g[la,lb], K[la,lb]},
   Equations -> 
   {
@@ -344,7 +352,8 @@ convertToADMBaseCalcBSSN =
 evolCalc =
 {
   Name -> "ML_ADM_RHS",
-  Schedule -> {"IN MoL_CalcRHS"},
+  Schedule -> {"IN MoL_CalcRHS", "AT analysis"},
+  Where -> Interior,
   Shorthands -> {detg, gu[ua,ub], G[ua,lb,lc], R[la,lb], Km[ua,lb], trK},
   Equations -> 
   {
@@ -368,14 +377,110 @@ evolCalc =
   }
 }
 
+evolCalcBSSN =
+{
+  Name -> "ML_BSSN_RHS",
+  Schedule -> {"IN MoL_CalcRHS", "AT analysis"},
+  Where -> Interior,
+  Shorthands -> {detgt, ddetgt[la], gtu[ua,ub],
+                 dgtu[ua,ub,lc], ddgtu[ua,ub,lc,ld], Gt[ua,lb,lc],
+                 Rt[la,lb], Rphi[la,lb], R[la,lb],
+                 Atm[ua,lb], Atu[ua,ub],
+                 e4phi, em4phi, g[la,lb], detg,
+                 ddetg[la], gu[ua,ub], G[ua,lb,lc]},
+  Equations -> 
+  {
+    detgt        -> 1 (* detgtExpr *),
+    ddetgt[la]   -> 0 (* ddetgtExpr[la] *),
+    gtu[ua,ub]   -> 1/detgt detgtExpr MatrixInverse [gt[ua,ub]],
+    dgtu[ua,ub,lc] -> - gtu[ua,ud] gtu[ub,ue] PD[gt[ld,le],lc],
+    ddgtu[ua,ub,lc,ld] -> - dgtu[ua,ue,ld] gtu[ub,uf] PD[gt[le,lf],lc]
+                          - gtu[ua,ue] dgtu[ub,uf,ld] PD[gt[le,lf],lc]
+                          - gtu[ua,ue] gtu[ub,uf] PD[gt[le,lf],lc,ld],
+    Gt[ua,lb,lc] -> 1/2 gtu[ua,ud]
+                    (PD[gt[lb,ld],lc] + PD[gt[lc,ld],lb] - PD[gt[lb,lc],ld]),
+    
+    (* PRD 62, 044034 (2000), eqn. (18) *)
+    Rt[li,lj] -> - (1/2) gtu[ul,um] PD[gt[li,lj],ll,lm]
+                 + gt[lk,li] PD[Xt[uk],lj] + gt[lk,lj] PD[Xt[uk],li]
+                 + Xt[uk] gt[li,ln] Gt[un,lj,lk] + Xt[uk] gt[lj,ln] Gt[un,li,lk]
+                 + gtu[ul,um] (+ 2 Gt[uk,ll,li] gt[lj,ln] Gt[un,lk,lm]
+                               + 2 Gt[uk,ll,lj] gt[li,ln] Gt[un,lk,lm]
+                               + Gt[uk,li,lm] gt[lk,ln] Gt[un,ll,lj]),
+    (* PRD 62, 044034 (2000), eqn. (15) *)
+    (* TODO: Check that CDt takes the tensor weight of phi into account *)
+    Rphi[li,lj] -> - 2 CDt[phi,lj,li]
+                   - 2 gt[li,lj] gtu[ul,un] CDt[phi,ll,ln]
+                   + 4 CDt[phi,li] CDt[phi,lj]
+                   - 4 gt[li,lj] gtu[ul,un] CDt[phi,ln] CDt[phi,ll],
+    
+    R[la,lb] -> Rt[la,lb] + Rphi[la,lb],
+    
+    Atm[ua,lb] -> gtu[ua,uc] At[lc,lb],
+    Atu[ua,ub] -> Atm[ua,lc] gtu[ub,uc],
+    
+    e4phi       -> Exp [4 phi],
+    em4phi      -> 1 / e4phi,
+    g[la,lb]    -> e4phi gt[la,lb],
+    detg        -> detgExpr,
+    (* gu[ua,ub] -> 1/detg detgExpr MatrixInverse [g[ua,ub]], *)
+    gu[ua,ub]   -> em4phi gtu[ua,ub],
+    (* ddetg[la] -> PD[e4phi detg,la], *)
+    ddetg[la]   -> e4phi ddetgt[la] + 4 detgt e4phi PD[phi,la],
+    G[ua,lb,lc] -> Gt[ua,lb,lc]
+                   + 1/(2 detg) (+ KD[ua,lb] ddetg[lc] + KD[ua,lc] ddetg[lb]
+                                 - (1/3) g[lb,lc] gu[ua,ud] ddetg[ld]),
+    
+    (* PRD 62, 044034 (2000), eqn. (10) *)
+    dot[phi]       -> - (1/6) alpha trK
+                      + Lie[phi, beta] + (1/6) phi PD[beta[ua],la],
+    (* PRD 62, 044034 (2000), eqn. (9) *)
+    dot[gt[la,lb]] -> - 2 alpha At[la,lb]
+                      + Lie[gt[la,lb], beta] - (2/3) gt[la,lb] PD[beta[uc],lc],
+    (* PRD 62, 044034 (2000), eqn. (20) *)
+    dot[Xt[ui]]    -> - 2 Atu[ui,uj] PD[alpha,lj]
+                      + 2 alpha (+ Gt[ui,lj,lk] Atu[uk,uj]
+                                 - (2/3) gtu[ui,uj] PD[trK,lj]
+                                 + 6 Atu[ui,uj] PD[phi,lj])
+                      - (+ (+ PD[beta[ul],lj] dgtu[ui,uj,ll]
+                            + beta[ul] ddgtu[ui,uj,ll,lj])
+                         - 2 (+ dgtu[um,uj,lj] PD[beta[ui],lm]
+                              + dgtu[um,ui,lj] PD[beta[uj],lm]
+                              + gtu[um,uj] PD[beta[ui],lm,lj]
+                              + gtu[um,ui] PD[beta[uj],lm,lj])
+                         + (2/3) (+ dgtu[ui,uj,lj] PD[beta[ul],ll]
+                                  + gtu[ui,uj] PD[beta[ul],ll,lj])),
+    
+    (* PRD 62, 044034 (2000), eqn. (11) *)
+    dot[trK]       -> - gu[ua,ub] CD[alpha,la,lb]
+                      + alpha (Atm[ua,lb] Atm[ub,la] + (1/3) trK^2)
+                      + Lie[trK, beta],
+    (* PRD 62, 044034 (2000), eqn. (12) *)
+    dot[At[la,lb]] -> + em4phi (+ (- CD[alpha,la,lb] + alpha R[la,lb])
+                                - (1/3) g[la,lb] gu[uc,ud]
+                                        (- CD[alpha,lc,ld] + alpha R[lc,ld]))
+                      + alpha (trK At[la,lb] - 2 At[la,lc] Atm[uc,lb])
+                      + Lie[At[la,lb], beta] - (2/3) At[la,lb] PD[beta[uc],lc],
+    
+    dot[alpha]      -> (* TODO *)
+                       + Lie[alpha, beta],
+    dot[dtalpha]    -> (* TODO *)
+                       + Lie[dtalpha, beta],
+    dot[beta[ua]]   -> (* TODO *)
+                       + Lie[beta[ua], beta],
+    dot[dtbeta[ua]] -> (* TODO *)
+                       + Lie[dtbeta[ua], beta]
+  }
+}
+
 enforceCalcBSSN =
 {
   Name -> "ML_BSSN_enforce",
-  Schedule -> {"IN MoL_PostStep"},
+  Schedule -> {"IN MoL_PostStep AFTER BSSN_ApplyBoundConds"},
   Shorthands -> {detgt, gtu[ua,ub], trA},
   Equations -> 
   {
-    detgt -> detgtExpr,
+    detgt -> 1 (* detgtExpr *),
     gtu[ua,ub] -> 1/detgt detgtExpr MatrixInverse [gt[ua,ub]],
     
     trA -> gtu[ua,ub] At[la,lb],
@@ -423,8 +528,8 @@ constraintsCalcBSSN =
                  K[la,lb], Km[la,lb], gK[la,lb,lc]},
   Equations -> 
   {
-    detgt -> detgtExpr,
-    ddetgt[la] -> ddetgtExpr[la],
+    detgt        -> 1 (* detgtExpr *),
+    ddetgt[la]   -> 0 (* ddetgtExpr[la] *),
     gtu[ua,ub]   -> 1/detgt detgtExpr MatrixInverse [gt[ua,ub]],
     Gt[ua,lb,lc] -> 1/2 gtu[ua,ud]
                     (PD[gt[lb,ld],lc] + PD[gt[lc,ld],lb] - PD[gt[lb,lc],ld]),
@@ -528,6 +633,7 @@ calculationsBSSN =
   initialCalcBSSN,
   convertFromADMBaseCalcBSSN,
   convertFromADMBaseCalcBSSNGamma,
+  evolCalcBSSN,
   enforceCalcBSSN,
   convertToADMBaseCalcBSSN,
   constraintsCalcBSSN
diff --git a/m/McLachlan.sh b/m/McLachlan.sh
index ed08d97..7f095c1 100755
--- a/m/McLachlan.sh
+++ b/m/McLachlan.sh
@@ -6,9 +6,26 @@
 
 MATHEMATICA="/Applications/Mathematica.app/Contents/MacOS/MathKernel"
 
+# Remove old output
+rm -rf ML_ADM ML_BSSN
+
 # Run Mathematica to regenerate the code
 < McLachlan.m "$MATHEMATICA" | tee McLachlan.out
 
+if grep 'KrancError' McLachlan.out > /dev/null 2>&1; then
+    echo
+    echo "There was an error when running Kranc."
+    echo "The file McLachlan.out contains details."
+    echo
+    echo "*** The Cactus thorns have NOT been updated. ***"
+    echo
+    exit 1
+fi
+
 # Copy the source trees
 ./copy-if-changed.sh ML_ADM ../ML_ADM
 ./copy-if-changed.sh ML_BSSN ../ML_BSSN
+
+echo
+echo "The Cactus thorns have been successfully regenerated."
+echo
diff --git a/par/m_bssn.par b/par/m_bssn.par
index b54a213..f55771e 100644
--- a/par/m_bssn.par
+++ b/par/m_bssn.par
@@ -3,7 +3,7 @@ ActiveThorns = "
         ADMBase
         NaNChecker
         Carpet CarpetIOASCII CarpetIOBasic CarpetIOScalar CarpetLib CarpetReduce LoopControl
-        GSL
+        Formaline GSL
         GenericFD
         ML_BSSN
 "
@@ -21,17 +21,48 @@ CoordBase::boundary_size_z_upper = 2
 
 driver::ghost_size = 2
 
+
+
 ADMBase::initial_shift   = "zero"
 ADMBase::initial_dtlapse = "zero"
 ADMBase::initial_dtshift = "zero"
 
 ML_BSSN::my_initial_data = "Minkowski"
 
+
+
+IO::out_dir = $parfile
+
 IOBasic::outInfo_every = 1
 IOBasic::outInfo_vars = "
+        ML_BSSN::H
+        ML_BSSN::trKrhs
+"
+
+IOScalar::outScalar_every = 1
+IOScalar::outScalar_vars = "
+        ML_BSSN::Ham
+        ML_BSSN::mom
+        ML_BSSN::cons_detg
+        ML_BSSN::cons_Gamma
+        ML_BSSN::cons_traceA
+        ML_BSSN::log_confacrhs
+        ML_BSSN::metricrhs
+        ML_BSSN::Gammarhs
+        ML_BSSN::trace_curvrhs
+        ML_BSSN::curvrhs
+"
+
+IOASCII::out1D_every = 1
+IOASCII::out1D_vars = "
         ML_BSSN::Ham
         ML_BSSN::mom
         ML_BSSN::cons_detg
         ML_BSSN::cons_Gamma
         ML_BSSN::cons_traceA
+        ML_BSSN::log_confacrhs
+        ML_BSSN::metricrhs
+        ML_BSSN::Gammarhs
+        ML_BSSN::trace_curvrhs
+        ML_BSSN::curvrhs
 "