Merge branch 'master' into eschnett/dgfe

Conflicts:
	Tools/CodeGen/Jacobian.m

292 files changed, 3938 insertions, 1772 deletions

diff --git a/Auxiliary/Cactus/KrancNumericalTools/GenericFD/src/MathematicaCompat.h b/Auxiliary/Cactus/KrancNumericalTools/GenericFD/src/MathematicaCompat.h
index 28bcebc..b0c1eaf 100644
--- a/Auxiliary/Cactus/KrancNumericalTools/GenericFD/src/MathematicaCompat.h
+++ b/Auxiliary/Cactus/KrancNumericalTools/GenericFD/src/MathematicaCompat.h
@@ -6,6 +6,7 @@
 #ifdef KRANC_C
 #  define Abs(x)        (fabs(x))
 #  define Min(x, y)     (fmin(x,y))
+#  define Min3(x, y, z) (fmin(fmin((x), (y)), (z)))
 #  define Max(x, y)     (fmax(x,y))
 #  define IfThen(x,y,z) ((x) ? (y) : (z))
 #else
diff --git a/Doc/KrancDoc.tex b/Doc/KrancDoc.tex
index a39cb74..c4f06bc 100644
--- a/Doc/KrancDoc.tex
+++ b/Doc/KrancDoc.tex
@@ -968,6 +968,12 @@ same arguments, but they can be tensorial in nature.
 
   KeywordParameters & list of KeywordParameterDefinition structures & A list of parameter definition structures for all the keyword parameters which this thorn will define and use.  (optional) & \{\} \\
 
+  ParameterConditions & list of parameter conditions & Each condition
+  is of the form \{\textit{condition}, \textit{message}\}, where
+  \textit{condition} is a boolean expression in parameter names, and
+  \textit{message} is the message for a fatal error which is generated
+  when the thorn starts if \textit{condition} is not satisfied & \{\} \\
+
   InheritedImplementations & list of strings & A list of all the implementations which this thorn
                                                will inherit from.  This is necessary to use grid functions
                                                provided by these implementations.  (optional) & \{\} \\
diff --git a/Examples/Advect/configuration.ccl b/Examples/Advect/configuration.ccl
index 023aac7..0a66ec2 100644
--- a/Examples/Advect/configuration.ccl
+++ b/Examples/Advect/configuration.ccl
@@ -1,3 +1,6 @@
 # File produced by Kranc
 
 REQUIRES GenericFD
+OPTIONAL LoopControl
+{
+}
diff --git a/Examples/Advect/interface.ccl b/Examples/Advect/interface.ccl
index da4baae..7967093 100644
--- a/Examples/Advect/interface.ccl
+++ b/Examples/Advect/interface.ccl
@@ -10,6 +10,7 @@ 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
diff --git a/Examples/Advect/param.ccl b/Examples/Advect/param.ccl
index a0525ac..6abcaa4 100644
--- a/Examples/Advect/param.ccl
+++ b/Examples/Advect/param.ccl
@@ -8,6 +8,7 @@ shares: GenericFD
 shares: MethodOfLines
 
 USES CCTK_INT MoL_Num_Evolved_Vars
+USES CCTK_INT MoL_Num_ArrayEvolved_Vars
 
 restricted:
 CCTK_INT verbose "verbose" STEERABLE=ALWAYS
@@ -33,12 +34,6 @@ CCTK_REAL amp "amp"
   "*:*" :: ""
 } 0
 
-restricted:
-CCTK_REAL hlleAlpha "hlleAlpha"
-{
-  "*:*" :: ""
-} 0
-
 private:
 KEYWORD initial_data "initial_data"
 {
@@ -53,6 +48,12 @@ CCTK_INT Advect_MaxNumEvolvedVars "Number of evolved variables used by this thor
 } 1
 
 restricted:
+CCTK_INT Advect_MaxNumArrayEvolvedVars "Number of Array evolved variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_ArrayEvolved_Vars STEERABLE=RECOVER
+{
+  0:0 :: "Number of Array evolved variables used by this thorn"
+} 0
+
+restricted:
 CCTK_INT timelevels "Number of active timelevels" STEERABLE=RECOVER
 {
   0:3 :: ""
@@ -65,6 +66,12 @@ CCTK_INT rhs_timelevels "Number of active RHS timelevels" STEERABLE=RECOVER
 } 1
 
 restricted:
+CCTK_INT other_timelevels "Number of active timelevels for non-evolved grid functions" STEERABLE=RECOVER
+{
+  0:3 :: ""
+} 1
+
+restricted:
 CCTK_INT advect_initial_sine_calc_every "advect_initial_sine_calc_every" STEERABLE=ALWAYS
 {
   *:* :: ""
diff --git a/Examples/Advect/schedule.ccl b/Examples/Advect/schedule.ccl
index 5cac3e7..bad352a 100644
--- a/Examples/Advect/schedule.ccl
+++ b/Examples/Advect/schedule.ccl
@@ -1,11 +1,20 @@
 # File produced by Kranc
 
 
-STORAGE: F2rho_group[1]
+if (other_timelevels == 1)
+{
+  STORAGE: F2rho_group[1]
+}
 
-STORAGE: Frho_group[1]
+if (other_timelevels == 1)
+{
+  STORAGE: Frho_group[1]
+}
 
-STORAGE: v_group[1]
+if (other_timelevels == 1)
+{
+  STORAGE: v_group[1]
+}
 
 if (timelevels == 1)
 {
@@ -39,12 +48,6 @@ schedule Advect_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule Advect_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule Advect_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
@@ -57,6 +60,11 @@ if (CCTK_EQUALS(initial_data, "sine"))
   schedule advect_initial_sine at CCTK_INITIAL as advect_initial
   {
     LANG: C
+    READS:    grid::x
+    WRITES:   Advect::rho
+    WRITES:   Advect::v1
+    WRITES:   Advect::v2
+    WRITES:   Advect::v3
   } "advect_initial_sine"
 }
 
@@ -66,17 +74,33 @@ if (CCTK_EQUALS(initial_data, "shock"))
   schedule advect_initial_shock at CCTK_INITIAL as advect_initial
   {
     LANG: C
+    READS:    grid::x
+    WRITES:   Advect::rho
+    WRITES:   Advect::v1
+    WRITES:   Advect::v2
+    WRITES:   Advect::v3
   } "advect_initial_shock"
 }
 
 schedule advect_evol in MoL_CalcRHS
 {
   LANG: C
+  READS:    Advect::Frho1
+  READS:    Advect::Frho2
+  READS:    Advect::Frho3
+  WRITES:   Advect::rhorhs
 } "advect_evol"
 
 schedule advect_flux in MoL_PostStep after Advect_ApplyBCs
 {
   LANG: C
+  READS:    Advect::rho
+  READS:    Advect::v1
+  READS:    Advect::v2
+  READS:    Advect::v3
+  WRITES:   Advect::Frho1
+  WRITES:   Advect::Frho2
+  WRITES:   Advect::Frho3
 } "advect_flux"
 
 schedule Advect_SelectBoundConds in MoL_PostStep
@@ -92,6 +116,12 @@ schedule Advect_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
+schedule Advect_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
 schedule group ApplyBCs as Advect_ApplyBCs in MoL_PostStep after Advect_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/Advect/src/Differencing.h b/Examples/Advect/src/Differencing.h
index e30450d..5f3f7d8 100644
--- a/Examples/Advect/src/Differencing.h
+++ b/Examples/Advect/src/Differencing.h
@@ -1,39 +1,324 @@
-#define PDstandard2nd1(u) (p1o2dx*(-(u)[di*(-1)+dj*(0)+dk*(0)] + (u)[di*(1)+dj*(0)+dk*(0)]))
-#define PDstandard2nd2(u) (p1o2dy*(-(u)[di*(0)+dj*(-1)+dk*(0)] + (u)[di*(0)+dj*(1)+dk*(0)]))
-#define PDstandard2nd3(u) (p1o2dz*(-(u)[di*(0)+dj*(0)+dk*(-1)] + (u)[di*(0)+dj*(0)+dk*(1)]))
-#define PDstandard2nd11(u) (p1odx2*(-2*(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(-1)+dj*(0)+dk*(0)] + (u)[di*(1)+dj*(0)+dk*(0)]))
-#define PDstandard2nd22(u) (p1ody2*(-2*(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(0)+dj*(-1)+dk*(0)] + (u)[di*(0)+dj*(1)+dk*(0)]))
-#define PDstandard2nd33(u) (p1odz2*(-2*(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(0)+dj*(0)+dk*(-1)] + (u)[di*(0)+dj*(0)+dk*(1)]))
-#define PDstandard2nd12(u) (p1o4dxdy*((u)[di*(-1)+dj*(-1)+dk*(0)] - (u)[di*(-1)+dj*(1)+dk*(0)] - (u)[di*(1)+dj*(-1)+dk*(0)] + (u)[di*(1)+dj*(1)+dk*(0)]))
-#define PDstandard2nd13(u) (p1o4dxdz*((u)[di*(-1)+dj*(0)+dk*(-1)] - (u)[di*(-1)+dj*(0)+dk*(1)] - (u)[di*(1)+dj*(0)+dk*(-1)] + (u)[di*(1)+dj*(0)+dk*(1)]))
-#define PDstandard2nd21(u) (p1o4dxdy*((u)[di*(-1)+dj*(-1)+dk*(0)] - (u)[di*(-1)+dj*(1)+dk*(0)] - (u)[di*(1)+dj*(-1)+dk*(0)] + (u)[di*(1)+dj*(1)+dk*(0)]))
-#define PDstandard2nd23(u) (p1o4dydz*((u)[di*(0)+dj*(-1)+dk*(-1)] - (u)[di*(0)+dj*(-1)+dk*(1)] - (u)[di*(0)+dj*(1)+dk*(-1)] + (u)[di*(0)+dj*(1)+dk*(1)]))
-#define PDstandard2nd31(u) (p1o4dxdz*((u)[di*(-1)+dj*(0)+dk*(-1)] - (u)[di*(-1)+dj*(0)+dk*(1)] - (u)[di*(1)+dj*(0)+dk*(-1)] + (u)[di*(1)+dj*(0)+dk*(1)]))
-#define PDstandard2nd32(u) (p1o4dydz*((u)[di*(0)+dj*(-1)+dk*(-1)] - (u)[di*(0)+dj*(-1)+dk*(1)] - (u)[di*(0)+dj*(1)+dk*(-1)] + (u)[di*(0)+dj*(1)+dk*(1)]))
-#define PDstandard4th1(u) (p1o12dx*(-8*(u)[di*(-1)+dj*(0)+dk*(0)] + 8*(u)[di*(1)+dj*(0)+dk*(0)] + (u)[di*(-2)+dj*(0)+dk*(0)] - (u)[di*(2)+dj*(0)+dk*(0)]))
-#define PDstandard4th2(u) (p1o12dy*(-8*(u)[di*(0)+dj*(-1)+dk*(0)] + 8*(u)[di*(0)+dj*(1)+dk*(0)] + (u)[di*(0)+dj*(-2)+dk*(0)] - (u)[di*(0)+dj*(2)+dk*(0)]))
-#define PDstandard4th3(u) (p1o12dz*(-8*(u)[di*(0)+dj*(0)+dk*(-1)] + 8*(u)[di*(0)+dj*(0)+dk*(1)] + (u)[di*(0)+dj*(0)+dk*(-2)] - (u)[di*(0)+dj*(0)+dk*(2)]))
-#define PDstandard4th11(u) (pm1o12dx2*(30*(u)[di*(0)+dj*(0)+dk*(0)] - 16*((u)[di*(-1)+dj*(0)+dk*(0)] + (u)[di*(1)+dj*(0)+dk*(0)]) + (u)[di*(-2)+dj*(0)+dk*(0)] + (u)[di*(2)+dj*(0)+dk*(0)]))
-#define PDstandard4th22(u) (pm1o12dy2*(30*(u)[di*(0)+dj*(0)+dk*(0)] - 16*((u)[di*(0)+dj*(-1)+dk*(0)] + (u)[di*(0)+dj*(1)+dk*(0)]) + (u)[di*(0)+dj*(-2)+dk*(0)] + (u)[di*(0)+dj*(2)+dk*(0)]))
-#define PDstandard4th33(u) (pm1o12dz2*(30*(u)[di*(0)+dj*(0)+dk*(0)] - 16*((u)[di*(0)+dj*(0)+dk*(-1)] + (u)[di*(0)+dj*(0)+dk*(1)]) + (u)[di*(0)+dj*(0)+dk*(-2)] + (u)[di*(0)+dj*(0)+dk*(2)]))
-#define PDstandard4th12(u) (p1o144dxdy*(-64*((u)[di*(-1)+dj*(1)+dk*(0)] + (u)[di*(1)+dj*(-1)+dk*(0)]) + 64*((u)[di*(-1)+dj*(-1)+dk*(0)] + (u)[di*(1)+dj*(1)+dk*(0)]) + 8*((u)[di*(-1)+dj*(2)+dk*(0)] + (u)[di*(1)+dj*(-2)+dk*(0)] + (u)[di*(-2)+dj*(1)+dk*(0)] + (u)[di*(2)+dj*(-1)+dk*(0)]) - 8*((u)[di*(-1)+dj*(-2)+dk*(0)] + (u)[di*(1)+dj*(2)+dk*(0)] + (u)[di*(-2)+dj*(-1)+dk*(0)] + (u)[di*(2)+dj*(1)+dk*(0)]) + (u)[di*(-2)+dj*(-2)+dk*(0)] - (u)[di*(-2)+dj*(2)+dk*(0)] - (u)[di*(2)+dj*(-2)+dk*(0)] + (u)[di*(2)+dj*(2)+dk*(0)]))
-#define PDstandard4th13(u) (p1o144dxdz*(-64*((u)[di*(-1)+dj*(0)+dk*(1)] + (u)[di*(1)+dj*(0)+dk*(-1)]) + 64*((u)[di*(-1)+dj*(0)+dk*(-1)] + (u)[di*(1)+dj*(0)+dk*(1)]) + 8*((u)[di*(-1)+dj*(0)+dk*(2)] + (u)[di*(1)+dj*(0)+dk*(-2)] + (u)[di*(-2)+dj*(0)+dk*(1)] + (u)[di*(2)+dj*(0)+dk*(-1)]) - 8*((u)[di*(-1)+dj*(0)+dk*(-2)] + (u)[di*(1)+dj*(0)+dk*(2)] + (u)[di*(-2)+dj*(0)+dk*(-1)] + (u)[di*(2)+dj*(0)+dk*(1)]) + (u)[di*(-2)+dj*(0)+dk*(-2)] - (u)[di*(-2)+dj*(0)+dk*(2)] - (u)[di*(2)+dj*(0)+dk*(-2)] + (u)[di*(2)+dj*(0)+dk*(2)]))
-#define PDstandard4th21(u) (p1o144dxdy*(-64*((u)[di*(-1)+dj*(1)+dk*(0)] + (u)[di*(1)+dj*(-1)+dk*(0)]) + 64*((u)[di*(-1)+dj*(-1)+dk*(0)] + (u)[di*(1)+dj*(1)+dk*(0)]) + 8*((u)[di*(-1)+dj*(2)+dk*(0)] + (u)[di*(1)+dj*(-2)+dk*(0)] + (u)[di*(-2)+dj*(1)+dk*(0)] + (u)[di*(2)+dj*(-1)+dk*(0)]) - 8*((u)[di*(-1)+dj*(-2)+dk*(0)] + (u)[di*(1)+dj*(2)+dk*(0)] + (u)[di*(-2)+dj*(-1)+dk*(0)] + (u)[di*(2)+dj*(1)+dk*(0)]) + (u)[di*(-2)+dj*(-2)+dk*(0)] - (u)[di*(-2)+dj*(2)+dk*(0)] - (u)[di*(2)+dj*(-2)+dk*(0)] + (u)[di*(2)+dj*(2)+dk*(0)]))
-#define PDstandard4th23(u) (p1o144dydz*(-64*((u)[di*(0)+dj*(-1)+dk*(1)] + (u)[di*(0)+dj*(1)+dk*(-1)]) + 64*((u)[di*(0)+dj*(-1)+dk*(-1)] + (u)[di*(0)+dj*(1)+dk*(1)]) + 8*((u)[di*(0)+dj*(-1)+dk*(2)] + (u)[di*(0)+dj*(1)+dk*(-2)] + (u)[di*(0)+dj*(-2)+dk*(1)] + (u)[di*(0)+dj*(2)+dk*(-1)]) - 8*((u)[di*(0)+dj*(-1)+dk*(-2)] + (u)[di*(0)+dj*(1)+dk*(2)] + (u)[di*(0)+dj*(-2)+dk*(-1)] + (u)[di*(0)+dj*(2)+dk*(1)]) + (u)[di*(0)+dj*(-2)+dk*(-2)] - (u)[di*(0)+dj*(-2)+dk*(2)] - (u)[di*(0)+dj*(2)+dk*(-2)] + (u)[di*(0)+dj*(2)+dk*(2)]))
-#define PDstandard4th31(u) (p1o144dxdz*(-64*((u)[di*(-1)+dj*(0)+dk*(1)] + (u)[di*(1)+dj*(0)+dk*(-1)]) + 64*((u)[di*(-1)+dj*(0)+dk*(-1)] + (u)[di*(1)+dj*(0)+dk*(1)]) + 8*((u)[di*(-1)+dj*(0)+dk*(2)] + (u)[di*(1)+dj*(0)+dk*(-2)] + (u)[di*(-2)+dj*(0)+dk*(1)] + (u)[di*(2)+dj*(0)+dk*(-1)]) - 8*((u)[di*(-1)+dj*(0)+dk*(-2)] + (u)[di*(1)+dj*(0)+dk*(2)] + (u)[di*(-2)+dj*(0)+dk*(-1)] + (u)[di*(2)+dj*(0)+dk*(1)]) + (u)[di*(-2)+dj*(0)+dk*(-2)] - (u)[di*(-2)+dj*(0)+dk*(2)] - (u)[di*(2)+dj*(0)+dk*(-2)] + (u)[di*(2)+dj*(0)+dk*(2)]))
-#define PDstandard4th32(u) (p1o144dydz*(-64*((u)[di*(0)+dj*(-1)+dk*(1)] + (u)[di*(0)+dj*(1)+dk*(-1)]) + 64*((u)[di*(0)+dj*(-1)+dk*(-1)] + (u)[di*(0)+dj*(1)+dk*(1)]) + 8*((u)[di*(0)+dj*(-1)+dk*(2)] + (u)[di*(0)+dj*(1)+dk*(-2)] + (u)[di*(0)+dj*(-2)+dk*(1)] + (u)[di*(0)+dj*(2)+dk*(-1)]) - 8*((u)[di*(0)+dj*(-1)+dk*(-2)] + (u)[di*(0)+dj*(1)+dk*(2)] + (u)[di*(0)+dj*(-2)+dk*(-1)] + (u)[di*(0)+dj*(2)+dk*(1)]) + (u)[di*(0)+dj*(-2)+dk*(-2)] - (u)[di*(0)+dj*(-2)+dk*(2)] - (u)[di*(0)+dj*(2)+dk*(-2)] + (u)[di*(0)+dj*(2)+dk*(2)]))
-#define PDonesided2nd1(u) (pm1o2dx*(3*(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(2*dir1)+dj*(0)+dk*(0)] - 4*(u)[di*(dir1)+dj*(0)+dk*(0)])*dir1)
-#define PDonesided2nd2(u) (pm1o2dy*(3*(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(0)+dj*(2*dir2)+dk*(0)] - 4*(u)[di*(0)+dj*(dir2)+dk*(0)])*dir2)
-#define PDonesided2nd3(u) (pm1o2dz*(3*(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(0)+dj*(0)+dk*(2*dir3)] - 4*(u)[di*(0)+dj*(0)+dk*(dir3)])*dir3)
-#define DiffPlus1(u) (p1o1*(-(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(1)+dj*(0)+dk*(0)]))
-#define DiffPlus2(u) (p1o1*(-(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(0)+dj*(1)+dk*(0)]))
-#define DiffPlus3(u) (p1o1*(-(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(0)+dj*(0)+dk*(1)]))
-#define DiffMinus1(u) (p1o1*((u)[di*(0)+dj*(0)+dk*(0)] - (u)[di*(-1)+dj*(0)+dk*(0)]))
-#define DiffMinus2(u) (p1o1*((u)[di*(0)+dj*(0)+dk*(0)] - (u)[di*(0)+dj*(-1)+dk*(0)]))
-#define DiffMinus3(u) (p1o1*((u)[di*(0)+dj*(0)+dk*(0)] - (u)[di*(0)+dj*(0)+dk*(-1)]))
-#define ShiftMinus1(u) (p1o1*(u)[di*(-1)+dj*(0)+dk*(0)])
-#define ShiftMinus2(u) (p1o1*(u)[di*(0)+dj*(-1)+dk*(0)])
-#define ShiftMinus3(u) (p1o1*(u)[di*(0)+dj*(0)+dk*(-1)])
-#define PDplus1(u) (p1odx*(-(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(1)+dj*(0)+dk*(0)]))
-#define PDplus2(u) (p1ody*(-(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(0)+dj*(1)+dk*(0)]))
-#define PDplus3(u) (p1odz*(-(u)[di*(0)+dj*(0)+dk*(0)] + (u)[di*(0)+dj*(0)+dk*(1)]))
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd1(u) ((-KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1o2dx)
+#else
+#  define PDstandard2nd1(u) (PDstandard2nd1_impl(u,p1o2dx,cdj,cdk))
+static CCTK_REAL PDstandard2nd1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dx, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dx, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1o2dx;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd2(u) ((-KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1o2dy)
+#else
+#  define PDstandard2nd2(u) (PDstandard2nd2_impl(u,p1o2dy,cdj,cdk))
+static CCTK_REAL PDstandard2nd2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dy, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dy, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1o2dy;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd3(u) ((-KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1))*p1o2dz)
+#else
+#  define PDstandard2nd3(u) (PDstandard2nd3_impl(u,p1o2dz,cdj,cdk))
+static CCTK_REAL PDstandard2nd3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1))*p1o2dz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd11(u) ((-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1odx2)
+#else
+#  define PDstandard2nd11(u) (PDstandard2nd11_impl(u,p1odx2,cdj,cdk))
+static CCTK_REAL PDstandard2nd11_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odx2, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd11_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odx2, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1odx2;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd22(u) ((-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1ody2)
+#else
+#  define PDstandard2nd22(u) (PDstandard2nd22_impl(u,p1ody2,cdj,cdk))
+static CCTK_REAL PDstandard2nd22_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1ody2, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd22_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1ody2, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1ody2;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd33(u) ((-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1))*p1odz2)
+#else
+#  define PDstandard2nd33(u) (PDstandard2nd33_impl(u,p1odz2,cdj,cdk))
+static CCTK_REAL PDstandard2nd33_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odz2, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd33_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odz2, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1))*p1odz2;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd12(u) ((KRANC_GFOFFSET3D(u,-1,-1,0) - KRANC_GFOFFSET3D(u,-1,1,0) - KRANC_GFOFFSET3D(u,1,-1,0) + KRANC_GFOFFSET3D(u,1,1,0))*p1o4dxdy)
+#else
+#  define PDstandard2nd12(u) (PDstandard2nd12_impl(u,p1o4dxdy,cdj,cdk))
+static CCTK_REAL PDstandard2nd12_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dxdy, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd12_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dxdy, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (KRANC_GFOFFSET3D(u,-1,-1,0) - KRANC_GFOFFSET3D(u,-1,1,0) - KRANC_GFOFFSET3D(u,1,-1,0) + KRANC_GFOFFSET3D(u,1,1,0))*p1o4dxdy;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd13(u) ((KRANC_GFOFFSET3D(u,-1,0,-1) - KRANC_GFOFFSET3D(u,-1,0,1) - KRANC_GFOFFSET3D(u,1,0,-1) + KRANC_GFOFFSET3D(u,1,0,1))*p1o4dxdz)
+#else
+#  define PDstandard2nd13(u) (PDstandard2nd13_impl(u,p1o4dxdz,cdj,cdk))
+static CCTK_REAL PDstandard2nd13_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dxdz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd13_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dxdz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (KRANC_GFOFFSET3D(u,-1,0,-1) - KRANC_GFOFFSET3D(u,-1,0,1) - KRANC_GFOFFSET3D(u,1,0,-1) + KRANC_GFOFFSET3D(u,1,0,1))*p1o4dxdz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd21(u) ((KRANC_GFOFFSET3D(u,-1,-1,0) - KRANC_GFOFFSET3D(u,-1,1,0) - KRANC_GFOFFSET3D(u,1,-1,0) + KRANC_GFOFFSET3D(u,1,1,0))*p1o4dxdy)
+#else
+#  define PDstandard2nd21(u) (PDstandard2nd21_impl(u,p1o4dxdy,cdj,cdk))
+static CCTK_REAL PDstandard2nd21_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dxdy, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd21_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dxdy, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (KRANC_GFOFFSET3D(u,-1,-1,0) - KRANC_GFOFFSET3D(u,-1,1,0) - KRANC_GFOFFSET3D(u,1,-1,0) + KRANC_GFOFFSET3D(u,1,1,0))*p1o4dxdy;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd23(u) ((KRANC_GFOFFSET3D(u,0,-1,-1) - KRANC_GFOFFSET3D(u,0,-1,1) - KRANC_GFOFFSET3D(u,0,1,-1) + KRANC_GFOFFSET3D(u,0,1,1))*p1o4dydz)
+#else
+#  define PDstandard2nd23(u) (PDstandard2nd23_impl(u,p1o4dydz,cdj,cdk))
+static CCTK_REAL PDstandard2nd23_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dydz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd23_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dydz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (KRANC_GFOFFSET3D(u,0,-1,-1) - KRANC_GFOFFSET3D(u,0,-1,1) - KRANC_GFOFFSET3D(u,0,1,-1) + KRANC_GFOFFSET3D(u,0,1,1))*p1o4dydz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd31(u) ((KRANC_GFOFFSET3D(u,-1,0,-1) - KRANC_GFOFFSET3D(u,-1,0,1) - KRANC_GFOFFSET3D(u,1,0,-1) + KRANC_GFOFFSET3D(u,1,0,1))*p1o4dxdz)
+#else
+#  define PDstandard2nd31(u) (PDstandard2nd31_impl(u,p1o4dxdz,cdj,cdk))
+static CCTK_REAL PDstandard2nd31_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dxdz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd31_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dxdz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (KRANC_GFOFFSET3D(u,-1,0,-1) - KRANC_GFOFFSET3D(u,-1,0,1) - KRANC_GFOFFSET3D(u,1,0,-1) + KRANC_GFOFFSET3D(u,1,0,1))*p1o4dxdz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd32(u) ((KRANC_GFOFFSET3D(u,0,-1,-1) - KRANC_GFOFFSET3D(u,0,-1,1) - KRANC_GFOFFSET3D(u,0,1,-1) + KRANC_GFOFFSET3D(u,0,1,1))*p1o4dydz)
+#else
+#  define PDstandard2nd32(u) (PDstandard2nd32_impl(u,p1o4dydz,cdj,cdk))
+static CCTK_REAL PDstandard2nd32_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dydz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd32_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o4dydz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (KRANC_GFOFFSET3D(u,0,-1,-1) - KRANC_GFOFFSET3D(u,0,-1,1) - KRANC_GFOFFSET3D(u,0,1,-1) + KRANC_GFOFFSET3D(u,0,1,1))*p1o4dydz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th1(u) ((-8*KRANC_GFOFFSET3D(u,-1,0,0) + 8*KRANC_GFOFFSET3D(u,1,0,0) + KRANC_GFOFFSET3D(u,-2,0,0) - KRANC_GFOFFSET3D(u,2,0,0))*p1o12dx)
+#else
+#  define PDstandard4th1(u) (PDstandard4th1_impl(u,p1o12dx,cdj,cdk))
+static CCTK_REAL PDstandard4th1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o12dx, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o12dx, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-8*KRANC_GFOFFSET3D(u,-1,0,0) + 8*KRANC_GFOFFSET3D(u,1,0,0) + KRANC_GFOFFSET3D(u,-2,0,0) - KRANC_GFOFFSET3D(u,2,0,0))*p1o12dx;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th2(u) ((-8*KRANC_GFOFFSET3D(u,0,-1,0) + 8*KRANC_GFOFFSET3D(u,0,1,0) + KRANC_GFOFFSET3D(u,0,-2,0) - KRANC_GFOFFSET3D(u,0,2,0))*p1o12dy)
+#else
+#  define PDstandard4th2(u) (PDstandard4th2_impl(u,p1o12dy,cdj,cdk))
+static CCTK_REAL PDstandard4th2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o12dy, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o12dy, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-8*KRANC_GFOFFSET3D(u,0,-1,0) + 8*KRANC_GFOFFSET3D(u,0,1,0) + KRANC_GFOFFSET3D(u,0,-2,0) - KRANC_GFOFFSET3D(u,0,2,0))*p1o12dy;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th3(u) ((-8*KRANC_GFOFFSET3D(u,0,0,-1) + 8*KRANC_GFOFFSET3D(u,0,0,1) + KRANC_GFOFFSET3D(u,0,0,-2) - KRANC_GFOFFSET3D(u,0,0,2))*p1o12dz)
+#else
+#  define PDstandard4th3(u) (PDstandard4th3_impl(u,p1o12dz,cdj,cdk))
+static CCTK_REAL PDstandard4th3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o12dz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o12dz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-8*KRANC_GFOFFSET3D(u,0,0,-1) + 8*KRANC_GFOFFSET3D(u,0,0,1) + KRANC_GFOFFSET3D(u,0,0,-2) - KRANC_GFOFFSET3D(u,0,0,2))*p1o12dz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th11(u) ((30*KRANC_GFOFFSET3D(u,0,0,0) - 16*(KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0)) + KRANC_GFOFFSET3D(u,-2,0,0) + KRANC_GFOFFSET3D(u,2,0,0))*pm1o12dx2)
+#else
+#  define PDstandard4th11(u) (PDstandard4th11_impl(u,pm1o12dx2,cdj,cdk))
+static CCTK_REAL PDstandard4th11_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o12dx2, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th11_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o12dx2, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (30*KRANC_GFOFFSET3D(u,0,0,0) - 16*(KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0)) + KRANC_GFOFFSET3D(u,-2,0,0) + KRANC_GFOFFSET3D(u,2,0,0))*pm1o12dx2;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th22(u) ((30*KRANC_GFOFFSET3D(u,0,0,0) - 16*(KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0)) + KRANC_GFOFFSET3D(u,0,-2,0) + KRANC_GFOFFSET3D(u,0,2,0))*pm1o12dy2)
+#else
+#  define PDstandard4th22(u) (PDstandard4th22_impl(u,pm1o12dy2,cdj,cdk))
+static CCTK_REAL PDstandard4th22_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o12dy2, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th22_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o12dy2, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (30*KRANC_GFOFFSET3D(u,0,0,0) - 16*(KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0)) + KRANC_GFOFFSET3D(u,0,-2,0) + KRANC_GFOFFSET3D(u,0,2,0))*pm1o12dy2;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th33(u) ((30*KRANC_GFOFFSET3D(u,0,0,0) - 16*(KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1)) + KRANC_GFOFFSET3D(u,0,0,-2) + KRANC_GFOFFSET3D(u,0,0,2))*pm1o12dz2)
+#else
+#  define PDstandard4th33(u) (PDstandard4th33_impl(u,pm1o12dz2,cdj,cdk))
+static CCTK_REAL PDstandard4th33_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o12dz2, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th33_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o12dz2, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (30*KRANC_GFOFFSET3D(u,0,0,0) - 16*(KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1)) + KRANC_GFOFFSET3D(u,0,0,-2) + KRANC_GFOFFSET3D(u,0,0,2))*pm1o12dz2;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th12(u) ((-64*(KRANC_GFOFFSET3D(u,-1,1,0) + KRANC_GFOFFSET3D(u,1,-1,0)) + 64*(KRANC_GFOFFSET3D(u,-1,-1,0) + KRANC_GFOFFSET3D(u,1,1,0)) + 8*(KRANC_GFOFFSET3D(u,-1,2,0) + KRANC_GFOFFSET3D(u,1,-2,0) + KRANC_GFOFFSET3D(u,-2,1,0) + KRANC_GFOFFSET3D(u,2,-1,0)) - 8*(KRANC_GFOFFSET3D(u,-1,-2,0) + KRANC_GFOFFSET3D(u,1,2,0) + KRANC_GFOFFSET3D(u,-2,-1,0) + KRANC_GFOFFSET3D(u,2,1,0)) + KRANC_GFOFFSET3D(u,-2,-2,0) - KRANC_GFOFFSET3D(u,-2,2,0) - KRANC_GFOFFSET3D(u,2,-2,0) + KRANC_GFOFFSET3D(u,2,2,0))*p1o144dxdy)
+#else
+#  define PDstandard4th12(u) (PDstandard4th12_impl(u,p1o144dxdy,cdj,cdk))
+static CCTK_REAL PDstandard4th12_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dxdy, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th12_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dxdy, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-64*(KRANC_GFOFFSET3D(u,-1,1,0) + KRANC_GFOFFSET3D(u,1,-1,0)) + 64*(KRANC_GFOFFSET3D(u,-1,-1,0) + KRANC_GFOFFSET3D(u,1,1,0)) + 8*(KRANC_GFOFFSET3D(u,-1,2,0) + KRANC_GFOFFSET3D(u,1,-2,0) + KRANC_GFOFFSET3D(u,-2,1,0) + KRANC_GFOFFSET3D(u,2,-1,0)) - 8*(KRANC_GFOFFSET3D(u,-1,-2,0) + KRANC_GFOFFSET3D(u,1,2,0) + KRANC_GFOFFSET3D(u,-2,-1,0) + KRANC_GFOFFSET3D(u,2,1,0)) + KRANC_GFOFFSET3D(u,-2,-2,0) - KRANC_GFOFFSET3D(u,-2,2,0) - KRANC_GFOFFSET3D(u,2,-2,0) + KRANC_GFOFFSET3D(u,2,2,0))*p1o144dxdy;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th13(u) ((-64*(KRANC_GFOFFSET3D(u,-1,0,1) + KRANC_GFOFFSET3D(u,1,0,-1)) + 64*(KRANC_GFOFFSET3D(u,-1,0,-1) + KRANC_GFOFFSET3D(u,1,0,1)) + 8*(KRANC_GFOFFSET3D(u,-1,0,2) + KRANC_GFOFFSET3D(u,1,0,-2) + KRANC_GFOFFSET3D(u,-2,0,1) + KRANC_GFOFFSET3D(u,2,0,-1)) - 8*(KRANC_GFOFFSET3D(u,-1,0,-2) + KRANC_GFOFFSET3D(u,1,0,2) + KRANC_GFOFFSET3D(u,-2,0,-1) + KRANC_GFOFFSET3D(u,2,0,1)) + KRANC_GFOFFSET3D(u,-2,0,-2) - KRANC_GFOFFSET3D(u,-2,0,2) - KRANC_GFOFFSET3D(u,2,0,-2) + KRANC_GFOFFSET3D(u,2,0,2))*p1o144dxdz)
+#else
+#  define PDstandard4th13(u) (PDstandard4th13_impl(u,p1o144dxdz,cdj,cdk))
+static CCTK_REAL PDstandard4th13_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dxdz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th13_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dxdz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-64*(KRANC_GFOFFSET3D(u,-1,0,1) + KRANC_GFOFFSET3D(u,1,0,-1)) + 64*(KRANC_GFOFFSET3D(u,-1,0,-1) + KRANC_GFOFFSET3D(u,1,0,1)) + 8*(KRANC_GFOFFSET3D(u,-1,0,2) + KRANC_GFOFFSET3D(u,1,0,-2) + KRANC_GFOFFSET3D(u,-2,0,1) + KRANC_GFOFFSET3D(u,2,0,-1)) - 8*(KRANC_GFOFFSET3D(u,-1,0,-2) + KRANC_GFOFFSET3D(u,1,0,2) + KRANC_GFOFFSET3D(u,-2,0,-1) + KRANC_GFOFFSET3D(u,2,0,1)) + KRANC_GFOFFSET3D(u,-2,0,-2) - KRANC_GFOFFSET3D(u,-2,0,2) - KRANC_GFOFFSET3D(u,2,0,-2) + KRANC_GFOFFSET3D(u,2,0,2))*p1o144dxdz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th21(u) ((-64*(KRANC_GFOFFSET3D(u,-1,1,0) + KRANC_GFOFFSET3D(u,1,-1,0)) + 64*(KRANC_GFOFFSET3D(u,-1,-1,0) + KRANC_GFOFFSET3D(u,1,1,0)) + 8*(KRANC_GFOFFSET3D(u,-1,2,0) + KRANC_GFOFFSET3D(u,1,-2,0) + KRANC_GFOFFSET3D(u,-2,1,0) + KRANC_GFOFFSET3D(u,2,-1,0)) - 8*(KRANC_GFOFFSET3D(u,-1,-2,0) + KRANC_GFOFFSET3D(u,1,2,0) + KRANC_GFOFFSET3D(u,-2,-1,0) + KRANC_GFOFFSET3D(u,2,1,0)) + KRANC_GFOFFSET3D(u,-2,-2,0) - KRANC_GFOFFSET3D(u,-2,2,0) - KRANC_GFOFFSET3D(u,2,-2,0) + KRANC_GFOFFSET3D(u,2,2,0))*p1o144dxdy)
+#else
+#  define PDstandard4th21(u) (PDstandard4th21_impl(u,p1o144dxdy,cdj,cdk))
+static CCTK_REAL PDstandard4th21_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dxdy, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th21_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dxdy, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-64*(KRANC_GFOFFSET3D(u,-1,1,0) + KRANC_GFOFFSET3D(u,1,-1,0)) + 64*(KRANC_GFOFFSET3D(u,-1,-1,0) + KRANC_GFOFFSET3D(u,1,1,0)) + 8*(KRANC_GFOFFSET3D(u,-1,2,0) + KRANC_GFOFFSET3D(u,1,-2,0) + KRANC_GFOFFSET3D(u,-2,1,0) + KRANC_GFOFFSET3D(u,2,-1,0)) - 8*(KRANC_GFOFFSET3D(u,-1,-2,0) + KRANC_GFOFFSET3D(u,1,2,0) + KRANC_GFOFFSET3D(u,-2,-1,0) + KRANC_GFOFFSET3D(u,2,1,0)) + KRANC_GFOFFSET3D(u,-2,-2,0) - KRANC_GFOFFSET3D(u,-2,2,0) - KRANC_GFOFFSET3D(u,2,-2,0) + KRANC_GFOFFSET3D(u,2,2,0))*p1o144dxdy;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th23(u) ((-64*(KRANC_GFOFFSET3D(u,0,-1,1) + KRANC_GFOFFSET3D(u,0,1,-1)) + 64*(KRANC_GFOFFSET3D(u,0,-1,-1) + KRANC_GFOFFSET3D(u,0,1,1)) + 8*(KRANC_GFOFFSET3D(u,0,-1,2) + KRANC_GFOFFSET3D(u,0,1,-2) + KRANC_GFOFFSET3D(u,0,-2,1) + KRANC_GFOFFSET3D(u,0,2,-1)) - 8*(KRANC_GFOFFSET3D(u,0,-1,-2) + KRANC_GFOFFSET3D(u,0,1,2) + KRANC_GFOFFSET3D(u,0,-2,-1) + KRANC_GFOFFSET3D(u,0,2,1)) + KRANC_GFOFFSET3D(u,0,-2,-2) - KRANC_GFOFFSET3D(u,0,-2,2) - KRANC_GFOFFSET3D(u,0,2,-2) + KRANC_GFOFFSET3D(u,0,2,2))*p1o144dydz)
+#else
+#  define PDstandard4th23(u) (PDstandard4th23_impl(u,p1o144dydz,cdj,cdk))
+static CCTK_REAL PDstandard4th23_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dydz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th23_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dydz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-64*(KRANC_GFOFFSET3D(u,0,-1,1) + KRANC_GFOFFSET3D(u,0,1,-1)) + 64*(KRANC_GFOFFSET3D(u,0,-1,-1) + KRANC_GFOFFSET3D(u,0,1,1)) + 8*(KRANC_GFOFFSET3D(u,0,-1,2) + KRANC_GFOFFSET3D(u,0,1,-2) + KRANC_GFOFFSET3D(u,0,-2,1) + KRANC_GFOFFSET3D(u,0,2,-1)) - 8*(KRANC_GFOFFSET3D(u,0,-1,-2) + KRANC_GFOFFSET3D(u,0,1,2) + KRANC_GFOFFSET3D(u,0,-2,-1) + KRANC_GFOFFSET3D(u,0,2,1)) + KRANC_GFOFFSET3D(u,0,-2,-2) - KRANC_GFOFFSET3D(u,0,-2,2) - KRANC_GFOFFSET3D(u,0,2,-2) + KRANC_GFOFFSET3D(u,0,2,2))*p1o144dydz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th31(u) ((-64*(KRANC_GFOFFSET3D(u,-1,0,1) + KRANC_GFOFFSET3D(u,1,0,-1)) + 64*(KRANC_GFOFFSET3D(u,-1,0,-1) + KRANC_GFOFFSET3D(u,1,0,1)) + 8*(KRANC_GFOFFSET3D(u,-1,0,2) + KRANC_GFOFFSET3D(u,1,0,-2) + KRANC_GFOFFSET3D(u,-2,0,1) + KRANC_GFOFFSET3D(u,2,0,-1)) - 8*(KRANC_GFOFFSET3D(u,-1,0,-2) + KRANC_GFOFFSET3D(u,1,0,2) + KRANC_GFOFFSET3D(u,-2,0,-1) + KRANC_GFOFFSET3D(u,2,0,1)) + KRANC_GFOFFSET3D(u,-2,0,-2) - KRANC_GFOFFSET3D(u,-2,0,2) - KRANC_GFOFFSET3D(u,2,0,-2) + KRANC_GFOFFSET3D(u,2,0,2))*p1o144dxdz)
+#else
+#  define PDstandard4th31(u) (PDstandard4th31_impl(u,p1o144dxdz,cdj,cdk))
+static CCTK_REAL PDstandard4th31_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dxdz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th31_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dxdz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-64*(KRANC_GFOFFSET3D(u,-1,0,1) + KRANC_GFOFFSET3D(u,1,0,-1)) + 64*(KRANC_GFOFFSET3D(u,-1,0,-1) + KRANC_GFOFFSET3D(u,1,0,1)) + 8*(KRANC_GFOFFSET3D(u,-1,0,2) + KRANC_GFOFFSET3D(u,1,0,-2) + KRANC_GFOFFSET3D(u,-2,0,1) + KRANC_GFOFFSET3D(u,2,0,-1)) - 8*(KRANC_GFOFFSET3D(u,-1,0,-2) + KRANC_GFOFFSET3D(u,1,0,2) + KRANC_GFOFFSET3D(u,-2,0,-1) + KRANC_GFOFFSET3D(u,2,0,1)) + KRANC_GFOFFSET3D(u,-2,0,-2) - KRANC_GFOFFSET3D(u,-2,0,2) - KRANC_GFOFFSET3D(u,2,0,-2) + KRANC_GFOFFSET3D(u,2,0,2))*p1o144dxdz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard4th32(u) ((-64*(KRANC_GFOFFSET3D(u,0,-1,1) + KRANC_GFOFFSET3D(u,0,1,-1)) + 64*(KRANC_GFOFFSET3D(u,0,-1,-1) + KRANC_GFOFFSET3D(u,0,1,1)) + 8*(KRANC_GFOFFSET3D(u,0,-1,2) + KRANC_GFOFFSET3D(u,0,1,-2) + KRANC_GFOFFSET3D(u,0,-2,1) + KRANC_GFOFFSET3D(u,0,2,-1)) - 8*(KRANC_GFOFFSET3D(u,0,-1,-2) + KRANC_GFOFFSET3D(u,0,1,2) + KRANC_GFOFFSET3D(u,0,-2,-1) + KRANC_GFOFFSET3D(u,0,2,1)) + KRANC_GFOFFSET3D(u,0,-2,-2) - KRANC_GFOFFSET3D(u,0,-2,2) - KRANC_GFOFFSET3D(u,0,2,-2) + KRANC_GFOFFSET3D(u,0,2,2))*p1o144dydz)
+#else
+#  define PDstandard4th32(u) (PDstandard4th32_impl(u,p1o144dydz,cdj,cdk))
+static CCTK_REAL PDstandard4th32_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dydz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard4th32_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o144dydz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-64*(KRANC_GFOFFSET3D(u,0,-1,1) + KRANC_GFOFFSET3D(u,0,1,-1)) + 64*(KRANC_GFOFFSET3D(u,0,-1,-1) + KRANC_GFOFFSET3D(u,0,1,1)) + 8*(KRANC_GFOFFSET3D(u,0,-1,2) + KRANC_GFOFFSET3D(u,0,1,-2) + KRANC_GFOFFSET3D(u,0,-2,1) + KRANC_GFOFFSET3D(u,0,2,-1)) - 8*(KRANC_GFOFFSET3D(u,0,-1,-2) + KRANC_GFOFFSET3D(u,0,1,2) + KRANC_GFOFFSET3D(u,0,-2,-1) + KRANC_GFOFFSET3D(u,0,2,1)) + KRANC_GFOFFSET3D(u,0,-2,-2) - KRANC_GFOFFSET3D(u,0,-2,2) - KRANC_GFOFFSET3D(u,0,2,-2) + KRANC_GFOFFSET3D(u,0,2,2))*p1o144dydz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDonesided2nd1(u) ((3*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,2*dir1,0,0) - 4*KRANC_GFOFFSET3D(u,dir1,0,0))*pm1o2dx*dir1)
+#else
+#  define PDonesided2nd1(u) (PDonesided2nd1_impl(u,pm1o2dx,cdj,cdk,dir1,dir2,dir3))
+static CCTK_REAL PDonesided2nd1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o2dx, ptrdiff_t const cdj, ptrdiff_t const cdk, ptrdiff_t const dir1, ptrdiff_t const dir2, ptrdiff_t const dir3) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDonesided2nd1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o2dx, ptrdiff_t const cdj, ptrdiff_t const cdk, ptrdiff_t const dir1, ptrdiff_t const dir2, ptrdiff_t const dir3)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (3*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,2*dir1,0,0) - 4*KRANC_GFOFFSET3D(u,dir1,0,0))*pm1o2dx*dir1;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDonesided2nd2(u) ((3*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,2*dir2,0) - 4*KRANC_GFOFFSET3D(u,0,dir2,0))*pm1o2dy*dir2)
+#else
+#  define PDonesided2nd2(u) (PDonesided2nd2_impl(u,pm1o2dy,cdj,cdk,dir1,dir2,dir3))
+static CCTK_REAL PDonesided2nd2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o2dy, ptrdiff_t const cdj, ptrdiff_t const cdk, ptrdiff_t const dir1, ptrdiff_t const dir2, ptrdiff_t const dir3) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDonesided2nd2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o2dy, ptrdiff_t const cdj, ptrdiff_t const cdk, ptrdiff_t const dir1, ptrdiff_t const dir2, ptrdiff_t const dir3)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (3*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,2*dir2,0) - 4*KRANC_GFOFFSET3D(u,0,dir2,0))*pm1o2dy*dir2;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDonesided2nd3(u) ((3*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,2*dir3) - 4*KRANC_GFOFFSET3D(u,0,0,dir3))*pm1o2dz*dir3)
+#else
+#  define PDonesided2nd3(u) (PDonesided2nd3_impl(u,pm1o2dz,cdj,cdk,dir1,dir2,dir3))
+static CCTK_REAL PDonesided2nd3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o2dz, ptrdiff_t const cdj, ptrdiff_t const cdk, ptrdiff_t const dir1, ptrdiff_t const dir2, ptrdiff_t const dir3) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDonesided2nd3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const pm1o2dz, ptrdiff_t const cdj, ptrdiff_t const cdk, ptrdiff_t const dir1, ptrdiff_t const dir2, ptrdiff_t const dir3)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (3*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,2*dir3) - 4*KRANC_GFOFFSET3D(u,0,0,dir3))*pm1o2dz*dir3;
+}
+#endif
+
diff --git a/Examples/Advect/src/RegisterMoL.cc b/Examples/Advect/src/RegisterMoL.cc
index 3f9d2d5..fc9c8f4 100644
--- a/Examples/Advect/src/RegisterMoL.cc
+++ b/Examples/Advect/src/RegisterMoL.cc
@@ -13,5 +13,7 @@ extern "C" void Advect_RegisterVars(CCTK_ARGUMENTS)
   
   /* Register all the evolved grid functions with MoL */
   ierr += MoLRegisterEvolved(CCTK_VarIndex("Advect::rho"),  CCTK_VarIndex("Advect::rhorhs"));
+  
+  /* Register all the evolved Array functions with MoL */
   return;
 }
diff --git a/Examples/Advect/src/advect_evol.cc b/Examples/Advect/src/advect_evol.cc
index ec65120..b6365ab 100644
--- a/Examples/Advect/src/advect_evol.cc
+++ b/Examples/Advect/src/advect_evol.cc
@@ -12,13 +12,15 @@
 #include "cctk_Parameters.h"
 #include "GenericFD.h"
 #include "Differencing.h"
+#include "cctk_Loop.h"
+#include "loopcontrol.h"
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void advect_evol_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -32,43 +34,26 @@ extern "C" void advect_evol_SelectBCs(CCTK_ARGUMENTS)
   return;
 }
 
-static void advect_evol_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const min[3], int const max[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
+static void advect_evol_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
   DECLARE_CCTK_ARGUMENTS;
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare the variables used for looping over grid points */
-  CCTK_INT i, j, k;
-  // CCTK_INT index = INITVALUE;
-  
-  /* Declare finite differencing variables */
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering advect_evol_Body");
-  }
-  
-  if (cctk_iteration % advect_evol_calc_every != advect_evol_calc_offset)
-  {
-    return;
-  }
-  
-  const char *groups[] = {"Advect::Frho_group","Advect::rho_grouprhs"};
-  GenericFD_AssertGroupStorage(cctkGH, "advect_evol", 2, groups);
-  
-  GenericFD_EnsureStencilFits(cctkGH, "advect_evol", 1, 1, 1);
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
   ptrdiff_t const di = 1;
   ptrdiff_t const dj = CCTK_GFINDEX3D(cctkGH,0,1,0) - CCTK_GFINDEX3D(cctkGH,0,0,0);
   ptrdiff_t const dk = CCTK_GFINDEX3D(cctkGH,0,0,1) - CCTK_GFINDEX3D(cctkGH,0,0,0);
+  ptrdiff_t const cdi = sizeof(CCTK_REAL) * di;
+  ptrdiff_t const cdj = sizeof(CCTK_REAL) * dj;
+  ptrdiff_t const cdk = sizeof(CCTK_REAL) * dk;
   CCTK_REAL const dx = ToReal(CCTK_DELTA_SPACE(0));
   CCTK_REAL const dy = ToReal(CCTK_DELTA_SPACE(1));
   CCTK_REAL const dz = ToReal(CCTK_DELTA_SPACE(2));
   CCTK_REAL const dt = ToReal(CCTK_DELTA_TIME);
+  CCTK_REAL const t = ToReal(cctk_time);
   CCTK_REAL const dxi = INV(dx);
   CCTK_REAL const dyi = INV(dy);
   CCTK_REAL const dzi = INV(dz);
@@ -82,24 +67,20 @@ static void advect_evol_Body(cGH const * restrict const cctkGH, int const dir, i
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
-  CCTK_REAL const p1odx = INV(dx);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
-  CCTK_REAL const p1odz = INV(dz);
   CCTK_REAL const p1odz2 = INV(SQR(dz));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
   CCTK_REAL const pm1o12dy2 = -0.0833333333333333333333333333333*INV(SQR(dy));
@@ -108,38 +89,44 @@ static void advect_evol_Body(cGH const * restrict const cctkGH, int const dir, i
   CCTK_REAL const pm1o2dy = -0.5*INV(dy);
   CCTK_REAL const pm1o2dz = -0.5*INV(dz);
   
+  /* Assign local copies of arrays functions */
+  
+  
+  
+  /* Calculate temporaries and arrays functions */
+  
+  /* Copy local copies back to grid functions */
+  
   /* Loop over the grid points */
-  for (k = min[2]; k < max[2]; k++)
+  #pragma omp parallel
+  CCTK_LOOP3(advect_evol,
+    i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
-    for (j = min[1]; j < max[1]; j++)
-    {
-      for (i = min[0]; i < max[0]; i++)
-      {
-         int  const  index  =  CCTK_GFINDEX3D(cctkGH,i,j,k) ;
-        
-        /* Assign local copies of grid functions */
-        
-        CCTK_REAL Frho1L = Frho1[index];
-        CCTK_REAL Frho2L = Frho2[index];
-        CCTK_REAL Frho3L = Frho3[index];
-        
-        
-        /* Include user supplied include files */
-        
-        /* Precompute derivatives */
-        CCTK_REAL const PDstandard2nd1Frho1 = PDstandard2nd1(&Frho1[index]);
-        CCTK_REAL const PDstandard2nd2Frho2 = PDstandard2nd2(&Frho2[index]);
-        CCTK_REAL const PDstandard2nd3Frho3 = PDstandard2nd3(&Frho3[index]);
-        
-        /* Calculate temporaries and grid functions */
-        CCTK_REAL rhorhsL = PDstandard2nd1Frho1 + PDstandard2nd2Frho2 + 
-          PDstandard2nd3Frho3;
-        
-        /* Copy local copies back to grid functions */
-        rhorhs[index] = rhorhsL;
-      }
-    }
+    ptrdiff_t const index = di*i + dj*j + dk*k;
+    
+    /* Assign local copies of grid functions */
+    
+    CCTK_REAL Frho1L = Frho1[index];
+    CCTK_REAL Frho2L = Frho2[index];
+    CCTK_REAL Frho3L = Frho3[index];
+    
+    
+    /* Include user supplied include files */
+    
+    /* Precompute derivatives */
+    CCTK_REAL const PDstandard2nd1Frho1 = PDstandard2nd1(&Frho1[index]);
+    CCTK_REAL const PDstandard2nd2Frho2 = PDstandard2nd2(&Frho2[index]);
+    CCTK_REAL const PDstandard2nd3Frho3 = PDstandard2nd3(&Frho3[index]);
+    
+    /* Calculate temporaries and grid functions */
+    CCTK_REAL rhorhsL = PDstandard2nd1Frho1 + PDstandard2nd2Frho2 + 
+      PDstandard2nd3Frho3;
+    
+    /* Copy local copies back to grid functions */
+    rhorhs[index] = rhorhsL;
   }
+  CCTK_ENDLOOP3(advect_evol);
 }
 
 extern "C" void advect_evol(CCTK_ARGUMENTS)
@@ -147,5 +134,28 @@ extern "C" void advect_evol(CCTK_ARGUMENTS)
   DECLARE_CCTK_ARGUMENTS;
   DECLARE_CCTK_PARAMETERS;
   
-  GenericFD_LoopOverInterior(cctkGH, &advect_evol_Body);
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Entering advect_evol_Body");
+  }
+  
+  if (cctk_iteration % advect_evol_calc_every != advect_evol_calc_offset)
+  {
+    return;
+  }
+  
+  const char *const groups[] = {
+    "Advect::Frho_group",
+    "Advect::rho_grouprhs"};
+  GenericFD_AssertGroupStorage(cctkGH, "advect_evol", 2, groups);
+  
+  GenericFD_EnsureStencilFits(cctkGH, "advect_evol", 1, 1, 1);
+  
+  GenericFD_LoopOverInterior(cctkGH, advect_evol_Body);
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Leaving advect_evol_Body");
+  }
 }
diff --git a/Examples/Advect/src/advect_flux.cc b/Examples/Advect/src/advect_flux.cc
index dd27e27..1375eb2 100644
--- a/Examples/Advect/src/advect_flux.cc
+++ b/Examples/Advect/src/advect_flux.cc
@@ -12,50 +12,36 @@
 #include "cctk_Parameters.h"
 #include "GenericFD.h"
 #include "Differencing.h"
+#include "cctk_Loop.h"
+#include "loopcontrol.h"
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
-static void advect_flux_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const min[3], int const max[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
+static void advect_flux_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
   DECLARE_CCTK_ARGUMENTS;
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare the variables used for looping over grid points */
-  CCTK_INT i, j, k;
-  // CCTK_INT index = INITVALUE;
-  
-  /* Declare finite differencing variables */
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering advect_flux_Body");
-  }
-  
-  if (cctk_iteration % advect_flux_calc_every != advect_flux_calc_offset)
-  {
-    return;
-  }
-  
-  const char *groups[] = {"Advect::Frho_group","Advect::rho_group","Advect::v_group"};
-  GenericFD_AssertGroupStorage(cctkGH, "advect_flux", 3, groups);
-  
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
   ptrdiff_t const di = 1;
   ptrdiff_t const dj = CCTK_GFINDEX3D(cctkGH,0,1,0) - CCTK_GFINDEX3D(cctkGH,0,0,0);
   ptrdiff_t const dk = CCTK_GFINDEX3D(cctkGH,0,0,1) - CCTK_GFINDEX3D(cctkGH,0,0,0);
+  ptrdiff_t const cdi = sizeof(CCTK_REAL) * di;
+  ptrdiff_t const cdj = sizeof(CCTK_REAL) * dj;
+  ptrdiff_t const cdk = sizeof(CCTK_REAL) * dk;
   CCTK_REAL const dx = ToReal(CCTK_DELTA_SPACE(0));
   CCTK_REAL const dy = ToReal(CCTK_DELTA_SPACE(1));
   CCTK_REAL const dz = ToReal(CCTK_DELTA_SPACE(2));
   CCTK_REAL const dt = ToReal(CCTK_DELTA_TIME);
+  CCTK_REAL const t = ToReal(cctk_time);
   CCTK_REAL const dxi = INV(dx);
   CCTK_REAL const dyi = INV(dy);
   CCTK_REAL const dzi = INV(dz);
@@ -69,24 +55,20 @@ static void advect_flux_Body(cGH const * restrict const cctkGH, int const dir, i
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
-  CCTK_REAL const p1odx = INV(dx);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
-  CCTK_REAL const p1odz = INV(dz);
   CCTK_REAL const p1odz2 = INV(SQR(dz));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
   CCTK_REAL const pm1o12dy2 = -0.0833333333333333333333333333333*INV(SQR(dy));
@@ -95,41 +77,47 @@ static void advect_flux_Body(cGH const * restrict const cctkGH, int const dir, i
   CCTK_REAL const pm1o2dy = -0.5*INV(dy);
   CCTK_REAL const pm1o2dz = -0.5*INV(dz);
   
+  /* Assign local copies of arrays functions */
+  
+  
+  
+  /* Calculate temporaries and arrays functions */
+  
+  /* Copy local copies back to grid functions */
+  
   /* Loop over the grid points */
-  for (k = min[2]; k < max[2]; k++)
+  #pragma omp parallel
+  CCTK_LOOP3(advect_flux,
+    i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
-    for (j = min[1]; j < max[1]; j++)
-    {
-      for (i = min[0]; i < max[0]; i++)
-      {
-         int  const  index  =  CCTK_GFINDEX3D(cctkGH,i,j,k) ;
-        
-        /* Assign local copies of grid functions */
-        
-        CCTK_REAL rhoL = rho[index];
-        CCTK_REAL v1L = v1[index];
-        CCTK_REAL v2L = v2[index];
-        CCTK_REAL v3L = v3[index];
-        
-        
-        /* Include user supplied include files */
-        
-        /* Precompute derivatives */
-        
-        /* Calculate temporaries and grid functions */
-        CCTK_REAL Frho1L = rhoL*v1L;
-        
-        CCTK_REAL Frho2L = rhoL*v2L;
-        
-        CCTK_REAL Frho3L = rhoL*v3L;
-        
-        /* Copy local copies back to grid functions */
-        Frho1[index] = Frho1L;
-        Frho2[index] = Frho2L;
-        Frho3[index] = Frho3L;
-      }
-    }
+    ptrdiff_t const index = di*i + dj*j + dk*k;
+    
+    /* Assign local copies of grid functions */
+    
+    CCTK_REAL rhoL = rho[index];
+    CCTK_REAL v1L = v1[index];
+    CCTK_REAL v2L = v2[index];
+    CCTK_REAL v3L = v3[index];
+    
+    
+    /* Include user supplied include files */
+    
+    /* Precompute derivatives */
+    
+    /* Calculate temporaries and grid functions */
+    CCTK_REAL Frho1L = rhoL*v1L;
+    
+    CCTK_REAL Frho2L = rhoL*v2L;
+    
+    CCTK_REAL Frho3L = rhoL*v3L;
+    
+    /* Copy local copies back to grid functions */
+    Frho1[index] = Frho1L;
+    Frho2[index] = Frho2L;
+    Frho3[index] = Frho3L;
   }
+  CCTK_ENDLOOP3(advect_flux);
 }
 
 extern "C" void advect_flux(CCTK_ARGUMENTS)
@@ -137,5 +125,28 @@ extern "C" void advect_flux(CCTK_ARGUMENTS)
   DECLARE_CCTK_ARGUMENTS;
   DECLARE_CCTK_PARAMETERS;
   
-  GenericFD_LoopOverEverything(cctkGH, &advect_flux_Body);
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Entering advect_flux_Body");
+  }
+  
+  if (cctk_iteration % advect_flux_calc_every != advect_flux_calc_offset)
+  {
+    return;
+  }
+  
+  const char *const groups[] = {
+    "Advect::Frho_group",
+    "Advect::rho_group",
+    "Advect::v_group"};
+  GenericFD_AssertGroupStorage(cctkGH, "advect_flux", 3, groups);
+  
+  
+  GenericFD_LoopOverEverything(cctkGH, advect_flux_Body);
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Leaving advect_flux_Body");
+  }
 }
diff --git a/Examples/Advect/src/advect_initial_shock.cc b/Examples/Advect/src/advect_initial_shock.cc
index 5c9706e..ee82bd8 100644
--- a/Examples/Advect/src/advect_initial_shock.cc
+++ b/Examples/Advect/src/advect_initial_shock.cc
@@ -12,50 +12,36 @@
 #include "cctk_Parameters.h"
 #include "GenericFD.h"
 #include "Differencing.h"
+#include "cctk_Loop.h"
+#include "loopcontrol.h"
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
-static void advect_initial_shock_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const min[3], int const max[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
+static void advect_initial_shock_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
   DECLARE_CCTK_ARGUMENTS;
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare the variables used for looping over grid points */
-  CCTK_INT i, j, k;
-  // CCTK_INT index = INITVALUE;
-  
-  /* Declare finite differencing variables */
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering advect_initial_shock_Body");
-  }
-  
-  if (cctk_iteration % advect_initial_shock_calc_every != advect_initial_shock_calc_offset)
-  {
-    return;
-  }
-  
-  const char *groups[] = {"grid::coordinates","Advect::rho_group","Advect::v_group"};
-  GenericFD_AssertGroupStorage(cctkGH, "advect_initial_shock", 3, groups);
-  
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
   ptrdiff_t const di = 1;
   ptrdiff_t const dj = CCTK_GFINDEX3D(cctkGH,0,1,0) - CCTK_GFINDEX3D(cctkGH,0,0,0);
   ptrdiff_t const dk = CCTK_GFINDEX3D(cctkGH,0,0,1) - CCTK_GFINDEX3D(cctkGH,0,0,0);
+  ptrdiff_t const cdi = sizeof(CCTK_REAL) * di;
+  ptrdiff_t const cdj = sizeof(CCTK_REAL) * dj;
+  ptrdiff_t const cdk = sizeof(CCTK_REAL) * dk;
   CCTK_REAL const dx = ToReal(CCTK_DELTA_SPACE(0));
   CCTK_REAL const dy = ToReal(CCTK_DELTA_SPACE(1));
   CCTK_REAL const dz = ToReal(CCTK_DELTA_SPACE(2));
   CCTK_REAL const dt = ToReal(CCTK_DELTA_TIME);
+  CCTK_REAL const t = ToReal(cctk_time);
   CCTK_REAL const dxi = INV(dx);
   CCTK_REAL const dyi = INV(dy);
   CCTK_REAL const dzi = INV(dz);
@@ -69,24 +55,20 @@ static void advect_initial_shock_Body(cGH const * restrict const cctkGH, int con
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
-  CCTK_REAL const p1odx = INV(dx);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
-  CCTK_REAL const p1odz = INV(dz);
   CCTK_REAL const p1odz2 = INV(SQR(dz));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
   CCTK_REAL const pm1o12dy2 = -0.0833333333333333333333333333333*INV(SQR(dy));
@@ -95,41 +77,47 @@ static void advect_initial_shock_Body(cGH const * restrict const cctkGH, int con
   CCTK_REAL const pm1o2dy = -0.5*INV(dy);
   CCTK_REAL const pm1o2dz = -0.5*INV(dz);
   
+  /* Assign local copies of arrays functions */
+  
+  
+  
+  /* Calculate temporaries and arrays functions */
+  
+  /* Copy local copies back to grid functions */
+  
   /* Loop over the grid points */
-  for (k = min[2]; k < max[2]; k++)
+  #pragma omp parallel
+  CCTK_LOOP3(advect_initial_shock,
+    i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
-    for (j = min[1]; j < max[1]; j++)
-    {
-      for (i = min[0]; i < max[0]; i++)
-      {
-         int  const  index  =  CCTK_GFINDEX3D(cctkGH,i,j,k) ;
-        
-        /* Assign local copies of grid functions */
-        
-        CCTK_REAL xL = x[index];
-        
-        
-        /* Include user supplied include files */
-        
-        /* Precompute derivatives */
-        
-        /* Calculate temporaries and grid functions */
-        CCTK_REAL v1L = ToReal(v0);
-        
-        CCTK_REAL v2L = 0;
-        
-        CCTK_REAL v3L = 0;
-        
-        CCTK_REAL rhoL = StepFunction(-0.5 + xL)*ToReal(amp);
-        
-        /* Copy local copies back to grid functions */
-        rho[index] = rhoL;
-        v1[index] = v1L;
-        v2[index] = v2L;
-        v3[index] = v3L;
-      }
-    }
+    ptrdiff_t const index = di*i + dj*j + dk*k;
+    
+    /* Assign local copies of grid functions */
+    
+    CCTK_REAL xL = x[index];
+    
+    
+    /* Include user supplied include files */
+    
+    /* Precompute derivatives */
+    
+    /* Calculate temporaries and grid functions */
+    CCTK_REAL v1L = ToReal(v0);
+    
+    CCTK_REAL v2L = 0;
+    
+    CCTK_REAL v3L = 0;
+    
+    CCTK_REAL rhoL = StepFunction(-0.5 + xL)*ToReal(amp);
+    
+    /* Copy local copies back to grid functions */
+    rho[index] = rhoL;
+    v1[index] = v1L;
+    v2[index] = v2L;
+    v3[index] = v3L;
   }
+  CCTK_ENDLOOP3(advect_initial_shock);
 }
 
 extern "C" void advect_initial_shock(CCTK_ARGUMENTS)
@@ -137,5 +125,28 @@ extern "C" void advect_initial_shock(CCTK_ARGUMENTS)
   DECLARE_CCTK_ARGUMENTS;
   DECLARE_CCTK_PARAMETERS;
   
-  GenericFD_LoopOverEverything(cctkGH, &advect_initial_shock_Body);
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Entering advect_initial_shock_Body");
+  }
+  
+  if (cctk_iteration % advect_initial_shock_calc_every != advect_initial_shock_calc_offset)
+  {
+    return;
+  }
+  
+  const char *const groups[] = {
+    "grid::coordinates",
+    "Advect::rho_group",
+    "Advect::v_group"};
+  GenericFD_AssertGroupStorage(cctkGH, "advect_initial_shock", 3, groups);
+  
+  
+  GenericFD_LoopOverEverything(cctkGH, advect_initial_shock_Body);
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Leaving advect_initial_shock_Body");
+  }
 }
diff --git a/Examples/Advect/src/advect_initial_sine.cc b/Examples/Advect/src/advect_initial_sine.cc
index 9e9f54d..69cec15 100644
--- a/Examples/Advect/src/advect_initial_sine.cc
+++ b/Examples/Advect/src/advect_initial_sine.cc
@@ -12,50 +12,36 @@
 #include "cctk_Parameters.h"
 #include "GenericFD.h"
 #include "Differencing.h"
+#include "cctk_Loop.h"
+#include "loopcontrol.h"
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
-static void advect_initial_sine_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const min[3], int const max[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
+static void advect_initial_sine_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
   DECLARE_CCTK_ARGUMENTS;
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare the variables used for looping over grid points */
-  CCTK_INT i, j, k;
-  // CCTK_INT index = INITVALUE;
-  
-  /* Declare finite differencing variables */
-  
-  if (verbose > 1)
-  {
-    CCTK_VInfo(CCTK_THORNSTRING,"Entering advect_initial_sine_Body");
-  }
-  
-  if (cctk_iteration % advect_initial_sine_calc_every != advect_initial_sine_calc_offset)
-  {
-    return;
-  }
-  
-  const char *groups[] = {"grid::coordinates","Advect::rho_group","Advect::v_group"};
-  GenericFD_AssertGroupStorage(cctkGH, "advect_initial_sine", 3, groups);
-  
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
   ptrdiff_t const di = 1;
   ptrdiff_t const dj = CCTK_GFINDEX3D(cctkGH,0,1,0) - CCTK_GFINDEX3D(cctkGH,0,0,0);
   ptrdiff_t const dk = CCTK_GFINDEX3D(cctkGH,0,0,1) - CCTK_GFINDEX3D(cctkGH,0,0,0);
+  ptrdiff_t const cdi = sizeof(CCTK_REAL) * di;
+  ptrdiff_t const cdj = sizeof(CCTK_REAL) * dj;
+  ptrdiff_t const cdk = sizeof(CCTK_REAL) * dk;
   CCTK_REAL const dx = ToReal(CCTK_DELTA_SPACE(0));
   CCTK_REAL const dy = ToReal(CCTK_DELTA_SPACE(1));
   CCTK_REAL const dz = ToReal(CCTK_DELTA_SPACE(2));
   CCTK_REAL const dt = ToReal(CCTK_DELTA_TIME);
+  CCTK_REAL const t = ToReal(cctk_time);
   CCTK_REAL const dxi = INV(dx);
   CCTK_REAL const dyi = INV(dy);
   CCTK_REAL const dzi = INV(dz);
@@ -69,24 +55,20 @@ static void advect_initial_sine_Body(cGH const * restrict const cctkGH, int cons
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
-  CCTK_REAL const p1odx = INV(dx);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
-  CCTK_REAL const p1odz = INV(dz);
   CCTK_REAL const p1odz2 = INV(SQR(dz));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
   CCTK_REAL const pm1o12dy2 = -0.0833333333333333333333333333333*INV(SQR(dy));
@@ -95,41 +77,47 @@ static void advect_initial_sine_Body(cGH const * restrict const cctkGH, int cons
   CCTK_REAL const pm1o2dy = -0.5*INV(dy);
   CCTK_REAL const pm1o2dz = -0.5*INV(dz);
   
+  /* Assign local copies of arrays functions */
+  
+  
+  
+  /* Calculate temporaries and arrays functions */
+  
+  /* Copy local copies back to grid functions */
+  
   /* Loop over the grid points */
-  for (k = min[2]; k < max[2]; k++)
+  #pragma omp parallel
+  CCTK_LOOP3(advect_initial_sine,
+    i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
-    for (j = min[1]; j < max[1]; j++)
-    {
-      for (i = min[0]; i < max[0]; i++)
-      {
-         int  const  index  =  CCTK_GFINDEX3D(cctkGH,i,j,k) ;
-        
-        /* Assign local copies of grid functions */
-        
-        CCTK_REAL xL = x[index];
-        
-        
-        /* Include user supplied include files */
-        
-        /* Precompute derivatives */
-        
-        /* Calculate temporaries and grid functions */
-        CCTK_REAL v1L = ToReal(v0);
-        
-        CCTK_REAL v2L = 0;
-        
-        CCTK_REAL v3L = 0;
-        
-        CCTK_REAL rhoL = 1 + Sin(2*Pi*xL)*ToReal(amp);
-        
-        /* Copy local copies back to grid functions */
-        rho[index] = rhoL;
-        v1[index] = v1L;
-        v2[index] = v2L;
-        v3[index] = v3L;
-      }
-    }
+    ptrdiff_t const index = di*i + dj*j + dk*k;
+    
+    /* Assign local copies of grid functions */
+    
+    CCTK_REAL xL = x[index];
+    
+    
+    /* Include user supplied include files */
+    
+    /* Precompute derivatives */
+    
+    /* Calculate temporaries and grid functions */
+    CCTK_REAL v1L = ToReal(v0);
+    
+    CCTK_REAL v2L = 0;
+    
+    CCTK_REAL v3L = 0;
+    
+    CCTK_REAL rhoL = 1 + sin(2*xL*Pi)*ToReal(amp);
+    
+    /* Copy local copies back to grid functions */
+    rho[index] = rhoL;
+    v1[index] = v1L;
+    v2[index] = v2L;
+    v3[index] = v3L;
   }
+  CCTK_ENDLOOP3(advect_initial_sine);
 }
 
 extern "C" void advect_initial_sine(CCTK_ARGUMENTS)
@@ -137,5 +125,28 @@ extern "C" void advect_initial_sine(CCTK_ARGUMENTS)
   DECLARE_CCTK_ARGUMENTS;
   DECLARE_CCTK_PARAMETERS;
   
-  GenericFD_LoopOverEverything(cctkGH, &advect_initial_sine_Body);
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Entering advect_initial_sine_Body");
+  }
+  
+  if (cctk_iteration % advect_initial_sine_calc_every != advect_initial_sine_calc_offset)
+  {
+    return;
+  }
+  
+  const char *const groups[] = {
+    "grid::coordinates",
+    "Advect::rho_group",
+    "Advect::v_group"};
+  GenericFD_AssertGroupStorage(cctkGH, "advect_initial_sine", 3, groups);
+  
+  
+  GenericFD_LoopOverEverything(cctkGH, advect_initial_sine_Body);
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Leaving advect_initial_sine_Body");
+  }
 }
diff --git a/Examples/Advect/src/make.code.defn b/Examples/Advect/src/make.code.defn
index 61f7edb..debbc2b 100644
--- a/Examples/Advect/src/make.code.defn
+++ b/Examples/Advect/src/make.code.defn
@@ -1,3 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc advect_initial_sine.cc advect_initial_shock.cc advect_evol.cc advect_flux.cc Boundaries.cc 
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc advect_initial_sine.cc advect_initial_shock.cc advect_evol.cc advect_flux.cc Boundaries.cc 
diff --git a/Examples/AdvectCaKernel/cakernel.ccl b/Examples/AdvectCaKernel/cakernel.ccl
index ddec99a..058f48a 100644
--- a/Examples/AdvectCaKernel/cakernel.ccl
+++ b/Examples/AdvectCaKernel/cakernel.ccl
@@ -1,15 +1,6 @@
-CCTK_CUDA_KERNEL initial_gaussian TYPE=gpu_cuda/3dblock STENCIL="0,0,0,0,0,0" TILE="8,8,8" SHARECODE=yes
+CCTK_CUDA_KERNEL initial_gaussian TYPE=gpu_cuda/3dblock TILE="8,8,8" SHARECODE=yes STENCIL="0,0,0,0,0,0"
 {
-  CCTK_CUDA_KERNEL_VARIABLE  cached=yes intent=out
-  {
-    phi
-  }
-  "phi"
-  
-  CCTK_CUDA_KERNEL_VARIABLE  cached=yes intent=in
-  {
-    x
-  }
-  "x"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out {phi} "phi"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in {x} "x"
 }
 
diff --git a/Examples/AdvectCaKernel/configuration.ccl b/Examples/AdvectCaKernel/configuration.ccl
index 0a66ec2..6d94724 100644
--- a/Examples/AdvectCaKernel/configuration.ccl
+++ b/Examples/AdvectCaKernel/configuration.ccl
@@ -4,3 +4,4 @@ REQUIRES GenericFD
 OPTIONAL LoopControl
 {
 }
+REQUIRES CUDA MPI
diff --git a/Examples/AdvectCaKernel/interface.ccl b/Examples/AdvectCaKernel/interface.ccl
index beec223..bac17d7 100644
--- a/Examples/AdvectCaKernel/interface.ccl
+++ b/Examples/AdvectCaKernel/interface.ccl
@@ -2,13 +2,14 @@
 
 implements: AdvectCaKernel
 
-inherits:   Grid GenericFD Boundary
+inherits:   Grid GenericFD Boundary Accelerator
 
 
 
 USES INCLUDE: GenericFD.h
 USES INCLUDE: Symmetry.h
 USES INCLUDE: sbp_calc_coeffs.h
+USES INCLUDE: CaCUDALib_driver_support.h
 USES INCLUDE: Boundary.h
 USES INCLUDE: loopcontrol.h
 
@@ -32,3 +33,14 @@ CCTK_REAL phi_g type=GF timelevels=1 tags=''
 {
   phi
 } "phi_g"
+
+# These functions are provided by the CaKernel thorn
+
+CCTK_INT FUNCTION Device_RegisterMem(CCTK_POINTER IN cctkGH, CCTK_INT IN vi, CCTK_INT IN num_tls)
+REQUIRES FUNCTION Device_RegisterMem
+
+CCTK_INT FUNCTION Device_UnRegisterMem(CCTK_POINTER IN cctkGH, CCTK_INT IN vi)
+REQUIRES FUNCTION Device_UnRegisterMem
+
+CCTK_POINTER FUNCTION Device_GetVarI (CCTK_POINTER IN cctkGH, CCTK_INT IN vi, CCTK_INT IN num_tls)
+REQUIRES FUNCTION Device_GetVarI
diff --git a/Examples/AdvectCaKernel/schedule.ccl b/Examples/AdvectCaKernel/schedule.ccl
index b83b7b8..f0cafb4 100644
--- a/Examples/AdvectCaKernel/schedule.ccl
+++ b/Examples/AdvectCaKernel/schedule.ccl
@@ -12,21 +12,18 @@ schedule AdvectCaKernel_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule AdvectCaKernel_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule AdvectCaKernel_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
   OPTIONS: meta
 } "register symmetries"
 
-schedule CAKERNEL_Launch_initial_gaussian AT INITIAL
+schedule CAKERNEL_Launch_initial_gaussian as initial_gaussian AT INITIAL
 {
   LANG: C
+  TAGS: Device=1
+  READS:    grid::x
+  WRITES:   AdvectCaKernel::phi
 } "initial_gaussian"
 
 schedule AdvectCaKernel_SelectBoundConds in MoL_PostStep
@@ -41,17 +38,19 @@ schedule AdvectCaKernel_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
-schedule CaKernel_CopyFromDev at ANALYSIS
+schedule AdvectCaKernel_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
+schedule AdvectCaKernel_Init in CCTK_BASEGRID after Accelerator_SetDevice
 {
   LANG: C
-} "Copy variables from devices"
+  OPTIONS: local
+} "Initialize CUDA Device"
 
 schedule group ApplyBCs as AdvectCaKernel_ApplyBCs in MoL_PostStep after AdvectCaKernel_SelectBoundConds
 {
   # no language specified
 } "Apply boundary conditions controlled by thorn Boundary"
-
-
-############################################################
-#CAKERNEL AUTO GENERATED PART. DO NOT EDIT BELOW THIS POINT#
-############################################################
diff --git a/Examples/AdvectCaKernel/src/CaKernel__initial_gaussian.code b/Examples/AdvectCaKernel/src/CaKernel__initial_gaussian.code
index 19ecad8..c239ee0 100644
--- a/Examples/AdvectCaKernel/src/CaKernel__initial_gaussian.code
+++ b/Examples/AdvectCaKernel/src/CaKernel__initial_gaussian.code
@@ -3,15 +3,16 @@
 #include "Differencing.h"
 #include "GenericFD.h"
 
+#undef KRANC_GFOFFSET3D
 #define KRANC_GFOFFSET3D(u,i,j,k) I3D(u,i,j,k)
 
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 CAKERNEL_initial_gaussian_Begin
   
diff --git a/Examples/AdvectCaKernel/src/make.code.defn b/Examples/AdvectCaKernel/src/make.code.defn
index 9f29474..b3329bd 100644
--- a/Examples/AdvectCaKernel/src/make.code.defn
+++ b/Examples/AdvectCaKernel/src/make.code.defn
@@ -1,8 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc Boundaries.cc 
-
-
-############################################################
-#CAKERNEL AUTO GENERATED PART. DO NOT EDIT BELOW THIS POINT#
-############################################################
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc Boundaries.cc 
diff --git a/Examples/Burgers/param.ccl b/Examples/Burgers/param.ccl
index 0b3226d..3a53840 100644
--- a/Examples/Burgers/param.ccl
+++ b/Examples/Burgers/param.ccl
@@ -52,12 +52,6 @@ CCTK_REAL alpha "alpha"
   "*:*" :: ""
 } 0
 
-restricted:
-CCTK_REAL hlleAlpha "hlleAlpha"
-{
-  "*:*" :: ""
-} 0
-
 private:
 KEYWORD initial_data "initial_data"
 {
diff --git a/Examples/Burgers/schedule.ccl b/Examples/Burgers/schedule.ccl
index 2384e1a..a52f5d3 100644
--- a/Examples/Burgers/schedule.ccl
+++ b/Examples/Burgers/schedule.ccl
@@ -48,12 +48,6 @@ schedule Burgers_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule Burgers_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule Burgers_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
@@ -66,6 +60,8 @@ if (CCTK_EQUALS(initial_data, "sine"))
   schedule burgers_initial_sine at CCTK_INITIAL as burgers_initial
   {
     LANG: C
+    READS:    grid::x
+    WRITES:   Burgers::u
   } "burgers_initial_sine"
 }
 
@@ -75,12 +71,15 @@ if (CCTK_EQUALS(initial_data, "shock"))
   schedule burgers_initial_shock at CCTK_INITIAL as burgers_initial
   {
     LANG: C
+    READS:    grid::x
+    WRITES:   Burgers::u
   } "burgers_initial_shock"
 }
 
 schedule burgers_zero_rhs in MoL_CalcRHS
 {
   LANG: C
+  WRITES:   Burgers::urhs
 } "burgers_zero_rhs"
 
 schedule group burgers_reconstruct_1_group in MoL_CalcRHS after burgers_zero_rhs
@@ -91,6 +90,9 @@ schedule group burgers_reconstruct_1_group in MoL_CalcRHS after burgers_zero_rhs
 schedule burgers_reconstruct_1 in burgers_reconstruct_1_group
 {
   LANG: C
+  READS:    Burgers::u
+  WRITES:   Burgers::uLeft
+  WRITES:   Burgers::uR
 } "burgers_reconstruct_1"
 
 schedule burgers_reconstruct_1_SelectBCs in burgers_reconstruct_1_bc_group
@@ -124,6 +126,9 @@ schedule group burgers_flux_1_group in MoL_CalcRHS after burgers_reconstruct_1
 schedule burgers_flux_1 in burgers_flux_1_group
 {
   LANG: C
+  READS:    Burgers::uLeft
+  READS:    Burgers::uR
+  WRITES:   Burgers::uF
 } "burgers_flux_1"
 
 schedule burgers_flux_1_SelectBCs in burgers_flux_1_bc_group
@@ -151,6 +156,9 @@ schedule group burgers_flux_1_bc_group in MoL_PseudoEvolutionBoundaries after Mo
 schedule burgers_rhs_1 in MoL_CalcRHS after burgers_flux_1
 {
   LANG: C
+  READS:    Burgers::uF
+  READS:    Burgers::urhs
+  WRITES:   Burgers::urhs
 } "burgers_rhs_1"
 
 schedule Burgers_SelectBoundConds in MoL_PostStep
@@ -166,6 +174,12 @@ schedule Burgers_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
+schedule Burgers_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
 schedule group ApplyBCs as Burgers_ApplyBCs in MoL_PostStep after Burgers_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/Burgers/src/burgers_flux_1.cc b/Examples/Burgers/src/burgers_flux_1.cc
index 947110f..a0a2300 100644
--- a/Examples/Burgers/src/burgers_flux_1.cc
+++ b/Examples/Burgers/src/burgers_flux_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void burgers_flux_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void burgers_flux_1_Body(cGH const * restrict const cctkGH, int const dir
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -84,9 +82,9 @@ static void burgers_flux_1_Body(cGH const * restrict const cctkGH, int const dir
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (burgers_flux_1,
+  CCTK_LOOP3(burgers_flux_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -108,7 +106,7 @@ static void burgers_flux_1_Body(cGH const * restrict const cctkGH, int const dir
     /* Copy local copies back to grid functions */
     uF[index] = uFL;
   }
-  CCTK_ENDLOOP3 (burgers_flux_1);
+  CCTK_ENDLOOP3(burgers_flux_1);
 }
 
 extern "C" void burgers_flux_1(CCTK_ARGUMENTS)
@@ -127,12 +125,15 @@ extern "C" void burgers_flux_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Burgers::uF_group","Burgers::uLeft_group","Burgers::uR_group"};
+  const char *const groups[] = {
+    "Burgers::uF_group",
+    "Burgers::uLeft_group",
+    "Burgers::uR_group"};
   GenericFD_AssertGroupStorage(cctkGH, "burgers_flux_1", 3, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "burgers_flux_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &burgers_flux_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, burgers_flux_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Burgers/src/burgers_initial_shock.cc b/Examples/Burgers/src/burgers_initial_shock.cc
index 6aaa0fc..22dc55a 100644
--- a/Examples/Burgers/src/burgers_initial_shock.cc
+++ b/Examples/Burgers/src/burgers_initial_shock.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void burgers_initial_shock_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void burgers_initial_shock_Body(cGH const * restrict const cctkGH, int co
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void burgers_initial_shock_Body(cGH const * restrict const cctkGH, int co
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (burgers_initial_shock,
+  CCTK_LOOP3(burgers_initial_shock,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -94,7 +92,7 @@ static void burgers_initial_shock_Body(cGH const * restrict const cctkGH, int co
     /* Copy local copies back to grid functions */
     u[index] = uL;
   }
-  CCTK_ENDLOOP3 (burgers_initial_shock);
+  CCTK_ENDLOOP3(burgers_initial_shock);
 }
 
 extern "C" void burgers_initial_shock(CCTK_ARGUMENTS)
@@ -113,11 +111,13 @@ extern "C" void burgers_initial_shock(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"grid::coordinates","Burgers::u_group"};
+  const char *const groups[] = {
+    "grid::coordinates",
+    "Burgers::u_group"};
   GenericFD_AssertGroupStorage(cctkGH, "burgers_initial_shock", 2, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &burgers_initial_shock_Body);
+  GenericFD_LoopOverEverything(cctkGH, burgers_initial_shock_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Burgers/src/burgers_initial_sine.cc b/Examples/Burgers/src/burgers_initial_sine.cc
index d6aa092..0e5daaa 100644
--- a/Examples/Burgers/src/burgers_initial_sine.cc
+++ b/Examples/Burgers/src/burgers_initial_sine.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void burgers_initial_sine_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void burgers_initial_sine_Body(cGH const * restrict const cctkGH, int con
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void burgers_initial_sine_Body(cGH const * restrict const cctkGH, int con
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (burgers_initial_sine,
+  CCTK_LOOP3(burgers_initial_sine,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -88,12 +86,12 @@ static void burgers_initial_sine_Body(cGH const * restrict const cctkGH, int con
     /* Precompute derivatives */
     
     /* Calculate temporaries and grid functions */
-    CCTK_REAL uL = 1 + Sin(2*xL*Pi)*ToReal(amp);
+    CCTK_REAL uL = 1 + sin(2*xL*Pi)*ToReal(amp);
     
     /* Copy local copies back to grid functions */
     u[index] = uL;
   }
-  CCTK_ENDLOOP3 (burgers_initial_sine);
+  CCTK_ENDLOOP3(burgers_initial_sine);
 }
 
 extern "C" void burgers_initial_sine(CCTK_ARGUMENTS)
@@ -112,11 +110,13 @@ extern "C" void burgers_initial_sine(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"grid::coordinates","Burgers::u_group"};
+  const char *const groups[] = {
+    "grid::coordinates",
+    "Burgers::u_group"};
   GenericFD_AssertGroupStorage(cctkGH, "burgers_initial_sine", 2, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &burgers_initial_sine_Body);
+  GenericFD_LoopOverEverything(cctkGH, burgers_initial_sine_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Burgers/src/burgers_reconstruct_1.cc b/Examples/Burgers/src/burgers_reconstruct_1.cc
index 4a79c1e..2a14321 100644
--- a/Examples/Burgers/src/burgers_reconstruct_1.cc
+++ b/Examples/Burgers/src/burgers_reconstruct_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void burgers_reconstruct_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -43,8 +43,6 @@ static void burgers_reconstruct_1_Body(cGH const * restrict const cctkGH, int co
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -87,9 +85,9 @@ static void burgers_reconstruct_1_Body(cGH const * restrict const cctkGH, int co
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (burgers_reconstruct_1,
+  CCTK_LOOP3(burgers_reconstruct_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -109,8 +107,8 @@ static void burgers_reconstruct_1_Body(cGH const * restrict const cctkGH, int co
     
     CCTK_REAL slopeR = DiffPlus1u;
     
-    CCTK_REAL slope = IfThen(slopeL*slopeR < 0,0,IfThen(Abs(slopeL) < 
-      Abs(slopeR),slopeL,slopeR));
+    CCTK_REAL slope = IfThen(slopeL*slopeR < 0,0,IfThen(fabs(slopeL) < 
+      fabs(slopeR),slopeL,slopeR));
     
     CCTK_REAL uLeftL = uL - 0.5*slope;
     
@@ -120,7 +118,7 @@ static void burgers_reconstruct_1_Body(cGH const * restrict const cctkGH, int co
     uLeft[index] = uLeftL;
     uR[index] = uRL;
   }
-  CCTK_ENDLOOP3 (burgers_reconstruct_1);
+  CCTK_ENDLOOP3(burgers_reconstruct_1);
 }
 
 extern "C" void burgers_reconstruct_1(CCTK_ARGUMENTS)
@@ -139,12 +137,15 @@ extern "C" void burgers_reconstruct_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Burgers::u_group","Burgers::uLeft_group","Burgers::uR_group"};
+  const char *const groups[] = {
+    "Burgers::u_group",
+    "Burgers::uLeft_group",
+    "Burgers::uR_group"};
   GenericFD_AssertGroupStorage(cctkGH, "burgers_reconstruct_1", 3, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "burgers_reconstruct_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &burgers_reconstruct_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, burgers_reconstruct_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Burgers/src/burgers_rhs_1.cc b/Examples/Burgers/src/burgers_rhs_1.cc
index 557e7a0..644aca7 100644
--- a/Examples/Burgers/src/burgers_rhs_1.cc
+++ b/Examples/Burgers/src/burgers_rhs_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void burgers_rhs_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void burgers_rhs_1_Body(cGH const * restrict const cctkGH, int const dir,
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -84,9 +82,9 @@ static void burgers_rhs_1_Body(cGH const * restrict const cctkGH, int const dir,
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (burgers_rhs_1,
+  CCTK_LOOP3(burgers_rhs_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -107,7 +105,7 @@ static void burgers_rhs_1_Body(cGH const * restrict const cctkGH, int const dir,
     /* Copy local copies back to grid functions */
     urhs[index] = urhsL;
   }
-  CCTK_ENDLOOP3 (burgers_rhs_1);
+  CCTK_ENDLOOP3(burgers_rhs_1);
 }
 
 extern "C" void burgers_rhs_1(CCTK_ARGUMENTS)
@@ -126,12 +124,14 @@ extern "C" void burgers_rhs_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Burgers::uF_group","Burgers::u_grouprhs"};
+  const char *const groups[] = {
+    "Burgers::uF_group",
+    "Burgers::u_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "burgers_rhs_1", 2, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "burgers_rhs_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &burgers_rhs_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, burgers_rhs_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Burgers/src/burgers_zero_rhs.cc b/Examples/Burgers/src/burgers_zero_rhs.cc
index 10f020f..689339b 100644
--- a/Examples/Burgers/src/burgers_zero_rhs.cc
+++ b/Examples/Burgers/src/burgers_zero_rhs.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void burgers_zero_rhs_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void burgers_zero_rhs_Body(cGH const * restrict const cctkGH, int const d
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void burgers_zero_rhs_Body(cGH const * restrict const cctkGH, int const d
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (burgers_zero_rhs,
+  CCTK_LOOP3(burgers_zero_rhs,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -92,7 +90,7 @@ static void burgers_zero_rhs_Body(cGH const * restrict const cctkGH, int const d
     /* Copy local copies back to grid functions */
     urhs[index] = urhsL;
   }
-  CCTK_ENDLOOP3 (burgers_zero_rhs);
+  CCTK_ENDLOOP3(burgers_zero_rhs);
 }
 
 extern "C" void burgers_zero_rhs(CCTK_ARGUMENTS)
@@ -111,11 +109,12 @@ extern "C" void burgers_zero_rhs(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Burgers::u_grouprhs"};
+  const char *const groups[] = {
+    "Burgers::u_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "burgers_zero_rhs", 1, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &burgers_zero_rhs_Body);
+  GenericFD_LoopOverEverything(cctkGH, burgers_zero_rhs_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Burgers/src/make.code.defn b/Examples/Burgers/src/make.code.defn
index cfdb103..513e66c 100644
--- a/Examples/Burgers/src/make.code.defn
+++ b/Examples/Burgers/src/make.code.defn
@@ -1,3 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc burgers_initial_sine.cc burgers_initial_shock.cc burgers_zero_rhs.cc burgers_reconstruct_1.cc burgers_flux_1.cc burgers_rhs_1.cc Boundaries.cc 
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc burgers_initial_sine.cc burgers_initial_shock.cc burgers_zero_rhs.cc burgers_reconstruct_1.cc burgers_flux_1.cc burgers_rhs_1.cc Boundaries.cc 
diff --git a/Examples/EM-xTensor.m b/Examples/EM-xTensor.m
index c1b480d..224e789 100644
--- a/Examples/EM-xTensor.m
+++ b/Examples/EM-xTensor.m
@@ -21,7 +21,15 @@
 
 $KrancTensorPackage="xTensorKranc`";
 Get["KrancTensor`"];
-Get["Metrics`LoadMetric`"];
+
+PrependTo[$Path, "../../EinsteinExact/m"];
+
+Check[Get["Metrics`LoadMetric`"],
+      Print["Cannot load Metrics package"]; Quit[1],
+      Get::noopen];
+
+Print["Using Metrics database at ", FindFile["Metrics`LoadMetric`"]];
+
 $DefInfoQ=False;
 $CVVerbose=False;
 $PrePrint=ScreenDollarIndices;
diff --git a/Examples/EM/param.ccl b/Examples/EM/param.ccl
index 4d95cbd..7b16dd2 100644
--- a/Examples/EM/param.ccl
+++ b/Examples/EM/param.ccl
@@ -23,12 +23,6 @@ CCTK_REAL sigma "sigma"
 } 0
 
 restricted:
-CCTK_REAL hlleAlpha "hlleAlpha"
-{
-  "*:*" :: ""
-} 0
-
-restricted:
 CCTK_INT EM_MaxNumEvolvedVars "Number of evolved variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_Evolved_Vars STEERABLE=RECOVER
 {
   6:6 :: "Number of evolved variables used by this thorn"
diff --git a/Examples/EM/schedule.ccl b/Examples/EM/schedule.ccl
index 3dfb80d..2ada2aa 100644
--- a/Examples/EM/schedule.ccl
+++ b/Examples/EM/schedule.ccl
@@ -69,12 +69,6 @@ schedule EM_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule EM_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule EM_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
@@ -84,11 +78,31 @@ schedule EM_RegisterSymmetries in SymmetryRegister
 schedule EM_initial at CCTK_INITIAL
 {
   LANG: C
+  READS:    grid::x
+  READS:    grid::y
+  WRITES:   EM::B1
+  WRITES:   EM::B2
+  WRITES:   EM::B3
+  WRITES:   EM::El1
+  WRITES:   EM::El2
+  WRITES:   EM::El3
 } "EM_initial"
 
 schedule EM_evol in MoL_CalcRHS
 {
   LANG: C
+  READS:    EM::B1
+  READS:    EM::B2
+  READS:    EM::B3
+  READS:    EM::El1
+  READS:    EM::El2
+  READS:    EM::El3
+  WRITES:   EM::B1rhs
+  WRITES:   EM::B2rhs
+  WRITES:   EM::B3rhs
+  WRITES:   EM::El1rhs
+  WRITES:   EM::El2rhs
+  WRITES:   EM::El3rhs
 } "EM_evol"
 
 schedule group EM_constraints_group in MoL_PseudoEvolution
@@ -99,6 +113,14 @@ schedule group EM_constraints_group in MoL_PseudoEvolution
 schedule EM_constraints in EM_constraints_group
 {
   LANG: C
+  READS:    EM::B1
+  READS:    EM::B2
+  READS:    EM::B3
+  READS:    EM::El1
+  READS:    EM::El2
+  READS:    EM::El3
+  WRITES:   EM::CB
+  WRITES:   EM::CEl
 } "EM_constraints"
 
 schedule EM_constraints_SelectBCs in EM_constraints_bc_group
@@ -131,6 +153,13 @@ schedule group EM_energy_group in MoL_PseudoEvolution
 schedule EM_energy in EM_energy_group
 {
   LANG: C
+  READS:    EM::B1
+  READS:    EM::B2
+  READS:    EM::B3
+  READS:    EM::El1
+  READS:    EM::El2
+  READS:    EM::El3
+  WRITES:   EM::rho
 } "EM_energy"
 
 schedule EM_SelectBoundConds in MoL_PostStep
@@ -147,6 +176,12 @@ schedule EM_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
+schedule EM_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
 schedule group ApplyBCs as EM_ApplyBCs in MoL_PostStep after EM_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/EM/src/Differencing.h b/Examples/EM/src/Differencing.h
index e6b9ac7..93bbe62 100644
--- a/Examples/EM/src/Differencing.h
+++ b/Examples/EM/src/Differencing.h
@@ -286,147 +286,3 @@ static CCTK_REAL PDstandard4th32_impl(CCTK_REAL const* restrict const u, CCTK_RE
 }
 #endif
 
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffPlus1(u) ((-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1o1)
-#else
-#  define DiffPlus1(u) (DiffPlus1_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffPlus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffPlus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffPlus2(u) ((-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1o1)
-#else
-#  define DiffPlus2(u) (DiffPlus2_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffPlus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffPlus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffPlus3(u) ((-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,1))*p1o1)
-#else
-#  define DiffPlus3(u) (DiffPlus3_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffPlus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffPlus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,1))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffMinus1(u) ((KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,-1,0,0))*p1o1)
-#else
-#  define DiffMinus1(u) (DiffMinus1_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffMinus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffMinus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,-1,0,0))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffMinus2(u) ((KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,0,-1,0))*p1o1)
-#else
-#  define DiffMinus2(u) (DiffMinus2_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffMinus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffMinus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,0,-1,0))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffMinus3(u) ((KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,0,0,-1))*p1o1)
-#else
-#  define DiffMinus3(u) (DiffMinus3_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffMinus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffMinus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,0,0,-1))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define ShiftMinus1(u) (KRANC_GFOFFSET3D(u,-1,0,0)*p1o1)
-#else
-#  define ShiftMinus1(u) (ShiftMinus1_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL ShiftMinus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL ShiftMinus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return KRANC_GFOFFSET3D(u,-1,0,0)*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define ShiftMinus2(u) (KRANC_GFOFFSET3D(u,0,-1,0)*p1o1)
-#else
-#  define ShiftMinus2(u) (ShiftMinus2_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL ShiftMinus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL ShiftMinus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return KRANC_GFOFFSET3D(u,0,-1,0)*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define ShiftMinus3(u) (KRANC_GFOFFSET3D(u,0,0,-1)*p1o1)
-#else
-#  define ShiftMinus3(u) (ShiftMinus3_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL ShiftMinus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL ShiftMinus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return KRANC_GFOFFSET3D(u,0,0,-1)*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define PDplus1(u) ((-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1odx)
-#else
-#  define PDplus1(u) (PDplus1_impl(u,p1odx,cdj,cdk))
-static CCTK_REAL PDplus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odx, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL PDplus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odx, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1odx;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define PDplus2(u) ((-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1ody)
-#else
-#  define PDplus2(u) (PDplus2_impl(u,p1ody,cdj,cdk))
-static CCTK_REAL PDplus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1ody, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL PDplus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1ody, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1ody;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define PDplus3(u) ((-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,1))*p1odz)
-#else
-#  define PDplus3(u) (PDplus3_impl(u,p1odz,cdj,cdk))
-static CCTK_REAL PDplus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL PDplus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odz, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,1))*p1odz;
-}
-#endif
-
diff --git a/Examples/EM/src/EM_constraints.cc b/Examples/EM/src/EM_constraints.cc
index dc40783..a03e93f 100644
--- a/Examples/EM/src/EM_constraints.cc
+++ b/Examples/EM/src/EM_constraints.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void EM_constraints_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void EM_constraints_Body(cGH const * restrict const cctkGH, int const dir
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -69,24 +67,20 @@ static void EM_constraints_Body(cGH const * restrict const cctkGH, int const dir
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
-  CCTK_REAL const p1odx = INV(dx);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
-  CCTK_REAL const p1odz = INV(dz);
   CCTK_REAL const p1odz2 = INV(SQR(dz));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
   CCTK_REAL const pm1o12dy2 = -0.0833333333333333333333333333333*INV(SQR(dy));
@@ -102,9 +96,9 @@ static void EM_constraints_Body(cGH const * restrict const cctkGH, int const dir
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (EM_constraints,
+  CCTK_LOOP3(EM_constraints,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -139,7 +133,7 @@ static void EM_constraints_Body(cGH const * restrict const cctkGH, int const dir
     CB[index] = CBL;
     CEl[index] = CElL;
   }
-  CCTK_ENDLOOP3 (EM_constraints);
+  CCTK_ENDLOOP3(EM_constraints);
 }
 
 extern "C" void EM_constraints(CCTK_ARGUMENTS)
@@ -158,12 +152,15 @@ extern "C" void EM_constraints(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EM::B_group","EM::constraints","EM::El_group"};
+  const char *const groups[] = {
+    "EM::B_group",
+    "EM::constraints",
+    "EM::El_group"};
   GenericFD_AssertGroupStorage(cctkGH, "EM_constraints", 3, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "EM_constraints", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &EM_constraints_Body);
+  GenericFD_LoopOverInterior(cctkGH, EM_constraints_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EM/src/EM_energy.cc b/Examples/EM/src/EM_energy.cc
index b8e1a17..410c9b3 100644
--- a/Examples/EM/src/EM_energy.cc
+++ b/Examples/EM/src/EM_energy.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void EM_energy_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void EM_energy_Body(cGH const * restrict const cctkGH, int const dir, int
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -57,24 +55,20 @@ static void EM_energy_Body(cGH const * restrict const cctkGH, int const dir, int
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
-  CCTK_REAL const p1odx = INV(dx);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
-  CCTK_REAL const p1odz = INV(dz);
   CCTK_REAL const p1odz2 = INV(SQR(dz));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
   CCTK_REAL const pm1o12dy2 = -0.0833333333333333333333333333333*INV(SQR(dy));
@@ -90,9 +84,9 @@ static void EM_energy_Body(cGH const * restrict const cctkGH, int const dir, int
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (EM_energy,
+  CCTK_LOOP3(EM_energy,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -117,7 +111,7 @@ static void EM_energy_Body(cGH const * restrict const cctkGH, int const dir, int
     /* Copy local copies back to grid functions */
     rho[index] = rhoL;
   }
-  CCTK_ENDLOOP3 (EM_energy);
+  CCTK_ENDLOOP3(EM_energy);
 }
 
 extern "C" void EM_energy(CCTK_ARGUMENTS)
@@ -136,11 +130,14 @@ extern "C" void EM_energy(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EM::B_group","EM::El_group","EM::endens"};
+  const char *const groups[] = {
+    "EM::B_group",
+    "EM::El_group",
+    "EM::endens"};
   GenericFD_AssertGroupStorage(cctkGH, "EM_energy", 3, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &EM_energy_Body);
+  GenericFD_LoopOverEverything(cctkGH, EM_energy_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EM/src/EM_evol.cc b/Examples/EM/src/EM_evol.cc
index ad67af3..80c756b 100644
--- a/Examples/EM/src/EM_evol.cc
+++ b/Examples/EM/src/EM_evol.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void EM_evol_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -43,8 +43,6 @@ static void EM_evol_Body(cGH const * restrict const cctkGH, int const dir, int c
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,24 +70,20 @@ static void EM_evol_Body(cGH const * restrict const cctkGH, int const dir, int c
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
-  CCTK_REAL const p1odx = INV(dx);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
-  CCTK_REAL const p1odz = INV(dz);
   CCTK_REAL const p1odz2 = INV(SQR(dz));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
   CCTK_REAL const pm1o12dy2 = -0.0833333333333333333333333333333*INV(SQR(dy));
@@ -105,9 +99,9 @@ static void EM_evol_Body(cGH const * restrict const cctkGH, int const dir, int c
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (EM_evol,
+  CCTK_LOOP3(EM_evol,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -158,7 +152,7 @@ static void EM_evol_Body(cGH const * restrict const cctkGH, int const dir, int c
     El2rhs[index] = El2rhsL;
     El3rhs[index] = El3rhsL;
   }
-  CCTK_ENDLOOP3 (EM_evol);
+  CCTK_ENDLOOP3(EM_evol);
 }
 
 extern "C" void EM_evol(CCTK_ARGUMENTS)
@@ -177,12 +171,16 @@ extern "C" void EM_evol(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EM::B_group","EM::B_grouprhs","EM::El_group","EM::El_grouprhs"};
+  const char *const groups[] = {
+    "EM::B_group",
+    "EM::B_grouprhs",
+    "EM::El_group",
+    "EM::El_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "EM_evol", 4, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "EM_evol", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &EM_evol_Body);
+  GenericFD_LoopOverInterior(cctkGH, EM_evol_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EM/src/EM_initial.cc b/Examples/EM/src/EM_initial.cc
index 8d0e0b0..727a18f 100644
--- a/Examples/EM/src/EM_initial.cc
+++ b/Examples/EM/src/EM_initial.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void EM_initial_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void EM_initial_Body(cGH const * restrict const cctkGH, int const dir, in
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -57,24 +55,20 @@ static void EM_initial_Body(cGH const * restrict const cctkGH, int const dir, in
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
-  CCTK_REAL const p1odx = INV(dx);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
-  CCTK_REAL const p1odz = INV(dz);
   CCTK_REAL const p1odz2 = INV(SQR(dz));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
   CCTK_REAL const pm1o12dy2 = -0.0833333333333333333333333333333*INV(SQR(dy));
@@ -90,9 +84,9 @@ static void EM_initial_Body(cGH const * restrict const cctkGH, int const dir, in
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (EM_initial,
+  CCTK_LOOP3(EM_initial,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -107,9 +101,9 @@ static void EM_initial_Body(cGH const * restrict const cctkGH, int const dir, in
     /* Precompute derivatives */
     
     /* Calculate temporaries and grid functions */
-    CCTK_REAL El1L = Cos(2*(xL + yL)*Pi)*ToReal(sigma);
+    CCTK_REAL El1L = cos(2*(xL + yL)*Pi)*ToReal(sigma);
     
-    CCTK_REAL El2L = Cos(2*xL*Pi)*(-1 + ToReal(sigma)) - Cos(2*(xL + 
+    CCTK_REAL El2L = cos(2*xL*Pi)*(-1 + ToReal(sigma)) - cos(2*(xL + 
       yL)*Pi)*ToReal(sigma);
     
     CCTK_REAL El3L = 0;
@@ -118,7 +112,7 @@ static void EM_initial_Body(cGH const * restrict const cctkGH, int const dir, in
     
     CCTK_REAL B2L = 0;
     
-    CCTK_REAL B3L = -(Cos(2*xL*Pi)*(-1 + ToReal(sigma))) + Cos(2*(xL + 
+    CCTK_REAL B3L = -(cos(2*xL*Pi)*(-1 + ToReal(sigma))) + cos(2*(xL + 
       yL)*Pi)*ToReal(sigma);
     
     /* Copy local copies back to grid functions */
@@ -129,7 +123,7 @@ static void EM_initial_Body(cGH const * restrict const cctkGH, int const dir, in
     El2[index] = El2L;
     El3[index] = El3L;
   }
-  CCTK_ENDLOOP3 (EM_initial);
+  CCTK_ENDLOOP3(EM_initial);
 }
 
 extern "C" void EM_initial(CCTK_ARGUMENTS)
@@ -148,11 +142,14 @@ extern "C" void EM_initial(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EM::B_group","EM::El_group","grid::coordinates"};
+  const char *const groups[] = {
+    "EM::B_group",
+    "EM::El_group",
+    "grid::coordinates"};
   GenericFD_AssertGroupStorage(cctkGH, "EM_initial", 3, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &EM_initial_Body);
+  GenericFD_LoopOverEverything(cctkGH, EM_initial_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EM/src/make.code.defn b/Examples/EM/src/make.code.defn
index 0d52b41..79facad 100644
--- a/Examples/EM/src/make.code.defn
+++ b/Examples/EM/src/make.code.defn
@@ -1,3 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc EM_initial.cc EM_evol.cc EM_constraints.cc EM_energy.cc Boundaries.cc 
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc EM_initial.cc EM_evol.cc EM_constraints.cc EM_energy.cc Boundaries.cc 
diff --git a/Examples/Euler/param.ccl b/Examples/Euler/param.ccl
index 96ee289..c14ea15 100644
--- a/Examples/Euler/param.ccl
+++ b/Examples/Euler/param.ccl
@@ -82,12 +82,6 @@ CCTK_REAL alpha "alpha"
   "*:*" :: ""
 } 0
 
-restricted:
-CCTK_REAL hlleAlpha "hlleAlpha"
-{
-  "*:*" :: ""
-} 0
-
 private:
 KEYWORD initial_data "initial_data"
 {
diff --git a/Examples/Euler/schedule.ccl b/Examples/Euler/schedule.ccl
index 0e5da74..a2a23c6 100644
--- a/Examples/Euler/schedule.ccl
+++ b/Examples/Euler/schedule.ccl
@@ -175,12 +175,6 @@ schedule Euler_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule Euler_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule Euler_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
@@ -193,22 +187,53 @@ if (CCTK_EQUALS(initial_data, "shock"))
   schedule euler_initial_shock at CCTK_INITIAL as euler_initial
   {
     LANG: C
+    READS:    grid::x
+    WRITES:   Euler::p
+    WRITES:   Euler::rho
+    WRITES:   Euler::v1
+    WRITES:   Euler::v2
+    WRITES:   Euler::v3
   } "euler_initial_shock"
 }
 
 schedule euler_primitives in MoL_PostStep after Euler_ApplyBCs
 {
   LANG: C
+  READS:    Euler::Den
+  READS:    Euler::En
+  READS:    Euler::S1
+  READS:    Euler::S2
+  READS:    Euler::S3
+  WRITES:   Euler::p
+  WRITES:   Euler::rho
+  WRITES:   Euler::v1
+  WRITES:   Euler::v2
+  WRITES:   Euler::v3
 } "euler_primitives"
 
 schedule euler_conserved at INITIAL after euler_initial
 {
   LANG: C
+  READS:    Euler::p
+  READS:    Euler::rho
+  READS:    Euler::v1
+  READS:    Euler::v2
+  READS:    Euler::v3
+  WRITES:   Euler::Den
+  WRITES:   Euler::En
+  WRITES:   Euler::S1
+  WRITES:   Euler::S2
+  WRITES:   Euler::S3
 } "euler_conserved"
 
 schedule euler_zero_rhs in MoL_CalcRHS
 {
   LANG: C
+  WRITES:   Euler::Denrhs
+  WRITES:   Euler::Enrhs
+  WRITES:   Euler::S1rhs
+  WRITES:   Euler::S2rhs
+  WRITES:   Euler::S3rhs
 } "euler_zero_rhs"
 
 schedule group euler_reconstruct_1_group in MoL_CalcRHS after euler_zero_rhs
@@ -219,6 +244,21 @@ schedule group euler_reconstruct_1_group in MoL_CalcRHS after euler_zero_rhs
 schedule euler_reconstruct_1 in euler_reconstruct_1_group
 {
   LANG: C
+  READS:    Euler::p
+  READS:    Euler::rho
+  READS:    Euler::v1
+  READS:    Euler::v2
+  READS:    Euler::v3
+  WRITES:   Euler::pLeft
+  WRITES:   Euler::pRight
+  WRITES:   Euler::rhoLeft
+  WRITES:   Euler::rhoRight
+  WRITES:   Euler::vLeft1
+  WRITES:   Euler::vLeft2
+  WRITES:   Euler::vLeft3
+  WRITES:   Euler::vRight1
+  WRITES:   Euler::vRight2
+  WRITES:   Euler::vRight3
 } "euler_reconstruct_1"
 
 schedule euler_reconstruct_1_SelectBCs in euler_reconstruct_1_bc_group
@@ -251,6 +291,26 @@ schedule group euler_reconstruct_1_bc_group in MoL_PseudoEvolutionBoundaries aft
 schedule euler_conserved_flux_1 in MoL_CalcRHS after euler_reconstruct_1
 {
   LANG: C
+  READS:    Euler::pLeft
+  READS:    Euler::pRight
+  READS:    Euler::rhoLeft
+  READS:    Euler::rhoRight
+  READS:    Euler::vLeft1
+  READS:    Euler::vLeft2
+  READS:    Euler::vLeft3
+  READS:    Euler::vRight1
+  READS:    Euler::vRight2
+  READS:    Euler::vRight3
+  WRITES:   Euler::DenLeft
+  WRITES:   Euler::DenRight
+  WRITES:   Euler::EnLeft
+  WRITES:   Euler::EnRight
+  WRITES:   Euler::SLeft1
+  WRITES:   Euler::SLeft2
+  WRITES:   Euler::SLeft3
+  WRITES:   Euler::SRight1
+  WRITES:   Euler::SRight2
+  WRITES:   Euler::SRight3
 } "euler_conserved_flux_1"
 
 schedule group euler_flux_1_group in MoL_CalcRHS after euler_conserved_flux_1
@@ -261,6 +321,31 @@ schedule group euler_flux_1_group in MoL_CalcRHS after euler_conserved_flux_1
 schedule euler_flux_1 in euler_flux_1_group
 {
   LANG: C
+  READS:    Euler::DenLeft
+  READS:    Euler::DenRight
+  READS:    Euler::EnLeft
+  READS:    Euler::EnRight
+  READS:    Euler::pLeft
+  READS:    Euler::pRight
+  READS:    Euler::rhoLeft
+  READS:    Euler::rhoRight
+  READS:    Euler::SLeft1
+  READS:    Euler::SLeft2
+  READS:    Euler::SLeft3
+  READS:    Euler::SRight1
+  READS:    Euler::SRight2
+  READS:    Euler::SRight3
+  READS:    Euler::vLeft1
+  READS:    Euler::vLeft2
+  READS:    Euler::vLeft3
+  READS:    Euler::vRight1
+  READS:    Euler::vRight2
+  READS:    Euler::vRight3
+  WRITES:   Euler::DenF
+  WRITES:   Euler::EnF
+  WRITES:   Euler::SF1
+  WRITES:   Euler::SF2
+  WRITES:   Euler::SF3
 } "euler_flux_1"
 
 schedule euler_flux_1_SelectBCs in euler_flux_1_bc_group
@@ -290,6 +375,21 @@ schedule group euler_flux_1_bc_group in MoL_PseudoEvolutionBoundaries after MoL_
 schedule euler_rhs_1 in MoL_CalcRHS after euler_flux_1
 {
   LANG: C
+  READS:    Euler::DenF
+  READS:    Euler::Denrhs
+  READS:    Euler::EnF
+  READS:    Euler::Enrhs
+  READS:    Euler::S1rhs
+  READS:    Euler::S2rhs
+  READS:    Euler::S3rhs
+  READS:    Euler::SF1
+  READS:    Euler::SF2
+  READS:    Euler::SF3
+  WRITES:   Euler::Denrhs
+  WRITES:   Euler::Enrhs
+  WRITES:   Euler::S1rhs
+  WRITES:   Euler::S2rhs
+  WRITES:   Euler::S3rhs
 } "euler_rhs_1"
 
 schedule Euler_SelectBoundConds in MoL_PostStep
@@ -307,6 +407,12 @@ schedule Euler_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
+schedule Euler_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
 schedule group ApplyBCs as Euler_ApplyBCs in MoL_PostStep after Euler_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/Euler/src/euler_conserved.cc b/Examples/Euler/src/euler_conserved.cc
index bfa9113..7f82841 100644
--- a/Examples/Euler/src/euler_conserved.cc
+++ b/Examples/Euler/src/euler_conserved.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void euler_conserved_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void euler_conserved_Body(cGH const * restrict const cctkGH, int const di
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -61,15 +59,15 @@ static void euler_conserved_Body(cGH const * restrict const cctkGH, int const di
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody = INV(dy);
@@ -93,9 +91,9 @@ static void euler_conserved_Body(cGH const * restrict const cctkGH, int const di
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (euler_conserved,
+  CCTK_LOOP3(euler_conserved,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -131,7 +129,7 @@ static void euler_conserved_Body(cGH const * restrict const cctkGH, int const di
     S2[index] = S2L;
     S3[index] = S3L;
   }
-  CCTK_ENDLOOP3 (euler_conserved);
+  CCTK_ENDLOOP3(euler_conserved);
 }
 
 extern "C" void euler_conserved(CCTK_ARGUMENTS)
@@ -150,11 +148,17 @@ extern "C" void euler_conserved(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Euler::Den_group","Euler::En_group","Euler::p_group","Euler::rho_group","Euler::S_group","Euler::v_group"};
+  const char *const groups[] = {
+    "Euler::Den_group",
+    "Euler::En_group",
+    "Euler::p_group",
+    "Euler::rho_group",
+    "Euler::S_group",
+    "Euler::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "euler_conserved", 6, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &euler_conserved_Body);
+  GenericFD_LoopOverEverything(cctkGH, euler_conserved_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Euler/src/euler_conserved_flux_1.cc b/Examples/Euler/src/euler_conserved_flux_1.cc
index 13cf71b..f0abdd5 100644
--- a/Examples/Euler/src/euler_conserved_flux_1.cc
+++ b/Examples/Euler/src/euler_conserved_flux_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void euler_conserved_flux_1_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void euler_conserved_flux_1_Body(cGH const * restrict const cctkGH, int c
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -61,15 +59,15 @@ static void euler_conserved_flux_1_Body(cGH const * restrict const cctkGH, int c
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody = INV(dy);
@@ -93,9 +91,9 @@ static void euler_conserved_flux_1_Body(cGH const * restrict const cctkGH, int c
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (euler_conserved_flux_1,
+  CCTK_LOOP3(euler_conserved_flux_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -154,7 +152,7 @@ static void euler_conserved_flux_1_Body(cGH const * restrict const cctkGH, int c
     SRight2[index] = SRight2L;
     SRight3[index] = SRight3L;
   }
-  CCTK_ENDLOOP3 (euler_conserved_flux_1);
+  CCTK_ENDLOOP3(euler_conserved_flux_1);
 }
 
 extern "C" void euler_conserved_flux_1(CCTK_ARGUMENTS)
@@ -173,11 +171,23 @@ extern "C" void euler_conserved_flux_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Euler::DenLeft_group","Euler::DenRight_group","Euler::EnLeft_group","Euler::EnRight_group","Euler::pLeft_group","Euler::pRight_group","Euler::rhoLeft_group","Euler::rhoRight_group","Euler::SLeft_group","Euler::SRight_group","Euler::vLeft_group","Euler::vRight_group"};
+  const char *const groups[] = {
+    "Euler::DenLeft_group",
+    "Euler::DenRight_group",
+    "Euler::EnLeft_group",
+    "Euler::EnRight_group",
+    "Euler::pLeft_group",
+    "Euler::pRight_group",
+    "Euler::rhoLeft_group",
+    "Euler::rhoRight_group",
+    "Euler::SLeft_group",
+    "Euler::SRight_group",
+    "Euler::vLeft_group",
+    "Euler::vRight_group"};
   GenericFD_AssertGroupStorage(cctkGH, "euler_conserved_flux_1", 12, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &euler_conserved_flux_1_Body);
+  GenericFD_LoopOverEverything(cctkGH, euler_conserved_flux_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Euler/src/euler_flux_1.cc b/Examples/Euler/src/euler_flux_1.cc
index 4786a56..4286e42 100644
--- a/Examples/Euler/src/euler_flux_1.cc
+++ b/Examples/Euler/src/euler_flux_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void euler_flux_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -46,8 +46,6 @@ static void euler_flux_1_Body(cGH const * restrict const cctkGH, int const dir,
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -79,15 +77,15 @@ static void euler_flux_1_Body(cGH const * restrict const cctkGH, int const dir,
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody = INV(dy);
@@ -111,9 +109,9 @@ static void euler_flux_1_Body(cGH const * restrict const cctkGH, int const dir,
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (euler_flux_1,
+  CCTK_LOOP3(euler_flux_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -189,7 +187,7 @@ static void euler_flux_1_Body(cGH const * restrict const cctkGH, int const dir,
     SF2[index] = SF2L;
     SF3[index] = SF3L;
   }
-  CCTK_ENDLOOP3 (euler_flux_1);
+  CCTK_ENDLOOP3(euler_flux_1);
 }
 
 extern "C" void euler_flux_1(CCTK_ARGUMENTS)
@@ -208,12 +206,27 @@ extern "C" void euler_flux_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Euler::DenF_group","Euler::DenLeft_group","Euler::DenRight_group","Euler::EnF_group","Euler::EnLeft_group","Euler::EnRight_group","Euler::pLeft_group","Euler::pRight_group","Euler::rhoLeft_group","Euler::rhoRight_group","Euler::SF_group","Euler::SLeft_group","Euler::SRight_group","Euler::vLeft_group","Euler::vRight_group"};
+  const char *const groups[] = {
+    "Euler::DenF_group",
+    "Euler::DenLeft_group",
+    "Euler::DenRight_group",
+    "Euler::EnF_group",
+    "Euler::EnLeft_group",
+    "Euler::EnRight_group",
+    "Euler::pLeft_group",
+    "Euler::pRight_group",
+    "Euler::rhoLeft_group",
+    "Euler::rhoRight_group",
+    "Euler::SF_group",
+    "Euler::SLeft_group",
+    "Euler::SRight_group",
+    "Euler::vLeft_group",
+    "Euler::vRight_group"};
   GenericFD_AssertGroupStorage(cctkGH, "euler_flux_1", 15, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "euler_flux_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &euler_flux_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, euler_flux_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Euler/src/euler_initial_shock.cc b/Examples/Euler/src/euler_initial_shock.cc
index e1350f0..73af884 100644
--- a/Examples/Euler/src/euler_initial_shock.cc
+++ b/Examples/Euler/src/euler_initial_shock.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void euler_initial_shock_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void euler_initial_shock_Body(cGH const * restrict const cctkGH, int cons
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -61,15 +59,15 @@ static void euler_initial_shock_Body(cGH const * restrict const cctkGH, int cons
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody = INV(dy);
@@ -93,9 +91,9 @@ static void euler_initial_shock_Body(cGH const * restrict const cctkGH, int cons
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (euler_initial_shock,
+  CCTK_LOOP3(euler_initial_shock,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -129,7 +127,7 @@ static void euler_initial_shock_Body(cGH const * restrict const cctkGH, int cons
     v2[index] = v2L;
     v3[index] = v3L;
   }
-  CCTK_ENDLOOP3 (euler_initial_shock);
+  CCTK_ENDLOOP3(euler_initial_shock);
 }
 
 extern "C" void euler_initial_shock(CCTK_ARGUMENTS)
@@ -148,11 +146,15 @@ extern "C" void euler_initial_shock(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"grid::coordinates","Euler::p_group","Euler::rho_group","Euler::v_group"};
+  const char *const groups[] = {
+    "grid::coordinates",
+    "Euler::p_group",
+    "Euler::rho_group",
+    "Euler::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "euler_initial_shock", 4, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &euler_initial_shock_Body);
+  GenericFD_LoopOverEverything(cctkGH, euler_initial_shock_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Euler/src/euler_primitives.cc b/Examples/Euler/src/euler_primitives.cc
index 6f28417..94e0338 100644
--- a/Examples/Euler/src/euler_primitives.cc
+++ b/Examples/Euler/src/euler_primitives.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void euler_primitives_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void euler_primitives_Body(cGH const * restrict const cctkGH, int const d
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -61,15 +59,15 @@ static void euler_primitives_Body(cGH const * restrict const cctkGH, int const d
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody = INV(dy);
@@ -93,9 +91,9 @@ static void euler_primitives_Body(cGH const * restrict const cctkGH, int const d
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (euler_primitives,
+  CCTK_LOOP3(euler_primitives,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -131,7 +129,7 @@ static void euler_primitives_Body(cGH const * restrict const cctkGH, int const d
     v2[index] = v2L;
     v3[index] = v3L;
   }
-  CCTK_ENDLOOP3 (euler_primitives);
+  CCTK_ENDLOOP3(euler_primitives);
 }
 
 extern "C" void euler_primitives(CCTK_ARGUMENTS)
@@ -150,11 +148,17 @@ extern "C" void euler_primitives(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Euler::Den_group","Euler::En_group","Euler::p_group","Euler::rho_group","Euler::S_group","Euler::v_group"};
+  const char *const groups[] = {
+    "Euler::Den_group",
+    "Euler::En_group",
+    "Euler::p_group",
+    "Euler::rho_group",
+    "Euler::S_group",
+    "Euler::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "euler_primitives", 6, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &euler_primitives_Body);
+  GenericFD_LoopOverEverything(cctkGH, euler_primitives_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Euler/src/euler_reconstruct_1.cc b/Examples/Euler/src/euler_reconstruct_1.cc
index 976472d..604cb0a 100644
--- a/Examples/Euler/src/euler_reconstruct_1.cc
+++ b/Examples/Euler/src/euler_reconstruct_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void euler_reconstruct_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -55,8 +55,6 @@ static void euler_reconstruct_1_Body(cGH const * restrict const cctkGH, int cons
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -88,15 +86,15 @@ static void euler_reconstruct_1_Body(cGH const * restrict const cctkGH, int cons
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody = INV(dy);
@@ -120,9 +118,9 @@ static void euler_reconstruct_1_Body(cGH const * restrict const cctkGH, int cons
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (euler_reconstruct_1,
+  CCTK_LOOP3(euler_reconstruct_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -212,7 +210,7 @@ static void euler_reconstruct_1_Body(cGH const * restrict const cctkGH, int cons
     vRight2[index] = vRight2L;
     vRight3[index] = vRight3L;
   }
-  CCTK_ENDLOOP3 (euler_reconstruct_1);
+  CCTK_ENDLOOP3(euler_reconstruct_1);
 }
 
 extern "C" void euler_reconstruct_1(CCTK_ARGUMENTS)
@@ -231,12 +229,21 @@ extern "C" void euler_reconstruct_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Euler::p_group","Euler::pLeft_group","Euler::pRight_group","Euler::rho_group","Euler::rhoLeft_group","Euler::rhoRight_group","Euler::v_group","Euler::vLeft_group","Euler::vRight_group"};
+  const char *const groups[] = {
+    "Euler::p_group",
+    "Euler::pLeft_group",
+    "Euler::pRight_group",
+    "Euler::rho_group",
+    "Euler::rhoLeft_group",
+    "Euler::rhoRight_group",
+    "Euler::v_group",
+    "Euler::vLeft_group",
+    "Euler::vRight_group"};
   GenericFD_AssertGroupStorage(cctkGH, "euler_reconstruct_1", 9, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "euler_reconstruct_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &euler_reconstruct_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, euler_reconstruct_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Euler/src/euler_rhs_1.cc b/Examples/Euler/src/euler_rhs_1.cc
index fa611a2..a2fa763 100644
--- a/Examples/Euler/src/euler_rhs_1.cc
+++ b/Examples/Euler/src/euler_rhs_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void euler_rhs_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -46,8 +46,6 @@ static void euler_rhs_1_Body(cGH const * restrict const cctkGH, int const dir, i
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -79,15 +77,15 @@ static void euler_rhs_1_Body(cGH const * restrict const cctkGH, int const dir, i
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody = INV(dy);
@@ -111,9 +109,9 @@ static void euler_rhs_1_Body(cGH const * restrict const cctkGH, int const dir, i
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (euler_rhs_1,
+  CCTK_LOOP3(euler_rhs_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -158,7 +156,7 @@ static void euler_rhs_1_Body(cGH const * restrict const cctkGH, int const dir, i
     S2rhs[index] = S2rhsL;
     S3rhs[index] = S3rhsL;
   }
-  CCTK_ENDLOOP3 (euler_rhs_1);
+  CCTK_ENDLOOP3(euler_rhs_1);
 }
 
 extern "C" void euler_rhs_1(CCTK_ARGUMENTS)
@@ -177,12 +175,18 @@ extern "C" void euler_rhs_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Euler::DenF_group","Euler::Den_grouprhs","Euler::EnF_group","Euler::En_grouprhs","Euler::SF_group","Euler::S_grouprhs"};
+  const char *const groups[] = {
+    "Euler::DenF_group",
+    "Euler::Den_grouprhs",
+    "Euler::EnF_group",
+    "Euler::En_grouprhs",
+    "Euler::SF_group",
+    "Euler::S_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "euler_rhs_1", 6, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "euler_rhs_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &euler_rhs_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, euler_rhs_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Euler/src/euler_zero_rhs.cc b/Examples/Euler/src/euler_zero_rhs.cc
index b5371b0..caabc05 100644
--- a/Examples/Euler/src/euler_zero_rhs.cc
+++ b/Examples/Euler/src/euler_zero_rhs.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void euler_zero_rhs_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void euler_zero_rhs_Body(cGH const * restrict const cctkGH, int const dir
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -61,15 +59,15 @@ static void euler_zero_rhs_Body(cGH const * restrict const cctkGH, int const dir
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody = INV(dy);
@@ -93,9 +91,9 @@ static void euler_zero_rhs_Body(cGH const * restrict const cctkGH, int const dir
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (euler_zero_rhs,
+  CCTK_LOOP3(euler_zero_rhs,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -125,7 +123,7 @@ static void euler_zero_rhs_Body(cGH const * restrict const cctkGH, int const dir
     S2rhs[index] = S2rhsL;
     S3rhs[index] = S3rhsL;
   }
-  CCTK_ENDLOOP3 (euler_zero_rhs);
+  CCTK_ENDLOOP3(euler_zero_rhs);
 }
 
 extern "C" void euler_zero_rhs(CCTK_ARGUMENTS)
@@ -144,11 +142,14 @@ extern "C" void euler_zero_rhs(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Euler::Den_grouprhs","Euler::En_grouprhs","Euler::S_grouprhs"};
+  const char *const groups[] = {
+    "Euler::Den_grouprhs",
+    "Euler::En_grouprhs",
+    "Euler::S_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "euler_zero_rhs", 3, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &euler_zero_rhs_Body);
+  GenericFD_LoopOverEverything(cctkGH, euler_zero_rhs_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Euler/src/make.code.defn b/Examples/Euler/src/make.code.defn
index 4081620..48ce643 100644
--- a/Examples/Euler/src/make.code.defn
+++ b/Examples/Euler/src/make.code.defn
@@ -1,3 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc euler_initial_shock.cc euler_primitives.cc euler_conserved.cc euler_zero_rhs.cc euler_reconstruct_1.cc euler_conserved_flux_1.cc euler_flux_1.cc euler_rhs_1.cc Boundaries.cc 
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc euler_initial_shock.cc euler_primitives.cc euler_conserved.cc euler_zero_rhs.cc euler_reconstruct_1.cc euler_conserved_flux_1.cc euler_flux_1.cc euler_rhs_1.cc Boundaries.cc 
diff --git a/Examples/EulerAuto/schedule.ccl b/Examples/EulerAuto/schedule.ccl
index 2911d7b..1b1eeda 100644
--- a/Examples/EulerAuto/schedule.ccl
+++ b/Examples/EulerAuto/schedule.ccl
@@ -175,12 +175,6 @@ schedule EulerAuto_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule EulerAuto_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule EulerAuto_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
@@ -193,22 +187,53 @@ if (CCTK_EQUALS(initial_data, "shock"))
   schedule eulerauto_initial_shock at CCTK_INITIAL as eulerauto_initial
   {
     LANG: C
+    READS:    grid::x
+    WRITES:   EulerAuto::p
+    WRITES:   EulerAuto::rho
+    WRITES:   EulerAuto::v1
+    WRITES:   EulerAuto::v2
+    WRITES:   EulerAuto::v3
   } "eulerauto_initial_shock"
 }
 
 schedule eulerauto_cons_calc_zero_rhs in MoL_CalcRHS
 {
   LANG: C
+  WRITES:   EulerAuto::Denrhs
+  WRITES:   EulerAuto::Enrhs
+  WRITES:   EulerAuto::S1rhs
+  WRITES:   EulerAuto::S2rhs
+  WRITES:   EulerAuto::S3rhs
 } "eulerauto_cons_calc_zero_rhs"
 
 schedule eulerauto_cons_calc_conserved at POSTINITIAL
 {
   LANG: C
+  READS:    EulerAuto::p
+  READS:    EulerAuto::rho
+  READS:    EulerAuto::v1
+  READS:    EulerAuto::v2
+  READS:    EulerAuto::v3
+  WRITES:   EulerAuto::Den
+  WRITES:   EulerAuto::En
+  WRITES:   EulerAuto::S1
+  WRITES:   EulerAuto::S2
+  WRITES:   EulerAuto::S3
 } "eulerauto_cons_calc_conserved"
 
 schedule eulerauto_cons_calc_primitives in MoL_PostStep after EulerAuto_ApplyBCs
 {
   LANG: C
+  READS:    EulerAuto::Den
+  READS:    EulerAuto::En
+  READS:    EulerAuto::S1
+  READS:    EulerAuto::S2
+  READS:    EulerAuto::S3
+  WRITES:   EulerAuto::p
+  WRITES:   EulerAuto::rho
+  WRITES:   EulerAuto::v1
+  WRITES:   EulerAuto::v2
+  WRITES:   EulerAuto::v3
 } "eulerauto_cons_calc_primitives"
 
 schedule group eulerauto_cons_calc_reconstruct_1_group in MoL_CalcRHS after eulerauto_cons_calc_zero_rhs
@@ -219,6 +244,21 @@ schedule group eulerauto_cons_calc_reconstruct_1_group in MoL_CalcRHS after eule
 schedule eulerauto_cons_calc_reconstruct_1 in eulerauto_cons_calc_reconstruct_1_group
 {
   LANG: C
+  READS:    EulerAuto::p
+  READS:    EulerAuto::rho
+  READS:    EulerAuto::v1
+  READS:    EulerAuto::v2
+  READS:    EulerAuto::v3
+  WRITES:   EulerAuto::pLeft
+  WRITES:   EulerAuto::pRight
+  WRITES:   EulerAuto::rhoLeft
+  WRITES:   EulerAuto::rhoRight
+  WRITES:   EulerAuto::v1Left
+  WRITES:   EulerAuto::v1Right
+  WRITES:   EulerAuto::v2Left
+  WRITES:   EulerAuto::v2Right
+  WRITES:   EulerAuto::v3Left
+  WRITES:   EulerAuto::v3Right
 } "eulerauto_cons_calc_reconstruct_1"
 
 schedule eulerauto_cons_calc_reconstruct_1_SelectBCs in eulerauto_cons_calc_reconstruct_1_bc_group
@@ -250,6 +290,26 @@ schedule group eulerauto_cons_calc_reconstruct_1_bc_group in MoL_PseudoEvolution
 schedule eulerauto_cons_calc_intercell_conserved_1 in MoL_CalcRHS after eulerauto_cons_calc_reconstruct_1
 {
   LANG: C
+  READS:    EulerAuto::pLeft
+  READS:    EulerAuto::pRight
+  READS:    EulerAuto::rhoLeft
+  READS:    EulerAuto::rhoRight
+  READS:    EulerAuto::v1Left
+  READS:    EulerAuto::v1Right
+  READS:    EulerAuto::v2Left
+  READS:    EulerAuto::v2Right
+  READS:    EulerAuto::v3Left
+  READS:    EulerAuto::v3Right
+  WRITES:   EulerAuto::DenLeft
+  WRITES:   EulerAuto::DenRight
+  WRITES:   EulerAuto::EnLeft
+  WRITES:   EulerAuto::EnRight
+  WRITES:   EulerAuto::S1Left
+  WRITES:   EulerAuto::S1Right
+  WRITES:   EulerAuto::S2Left
+  WRITES:   EulerAuto::S2Right
+  WRITES:   EulerAuto::S3Left
+  WRITES:   EulerAuto::S3Right
 } "eulerauto_cons_calc_intercell_conserved_1"
 
 schedule group eulerauto_cons_calc_flux_1_group in MoL_CalcRHS after eulerauto_cons_calc_intercell_conserved_1
@@ -260,6 +320,31 @@ schedule group eulerauto_cons_calc_flux_1_group in MoL_CalcRHS after eulerauto_c
 schedule eulerauto_cons_calc_flux_1 in eulerauto_cons_calc_flux_1_group
 {
   LANG: C
+  READS:    EulerAuto::DenLeft
+  READS:    EulerAuto::DenRight
+  READS:    EulerAuto::EnLeft
+  READS:    EulerAuto::EnRight
+  READS:    EulerAuto::pLeft
+  READS:    EulerAuto::pRight
+  READS:    EulerAuto::rhoLeft
+  READS:    EulerAuto::rhoRight
+  READS:    EulerAuto::S1Left
+  READS:    EulerAuto::S1Right
+  READS:    EulerAuto::S2Left
+  READS:    EulerAuto::S2Right
+  READS:    EulerAuto::S3Left
+  READS:    EulerAuto::S3Right
+  READS:    EulerAuto::v1Left
+  READS:    EulerAuto::v1Right
+  READS:    EulerAuto::v2Left
+  READS:    EulerAuto::v2Right
+  READS:    EulerAuto::v3Left
+  READS:    EulerAuto::v3Right
+  WRITES:   EulerAuto::DenFlux
+  WRITES:   EulerAuto::EnFlux
+  WRITES:   EulerAuto::S1Flux
+  WRITES:   EulerAuto::S2Flux
+  WRITES:   EulerAuto::S3Flux
 } "eulerauto_cons_calc_flux_1"
 
 schedule eulerauto_cons_calc_flux_1_SelectBCs in eulerauto_cons_calc_flux_1_bc_group
@@ -291,6 +376,21 @@ schedule group eulerauto_cons_calc_flux_1_bc_group in MoL_PseudoEvolutionBoundar
 schedule eulerauto_cons_calc_rhs_1 in MoL_CalcRHS after eulerauto_cons_calc_flux_1
 {
   LANG: C
+  READS:    EulerAuto::DenFlux
+  READS:    EulerAuto::Denrhs
+  READS:    EulerAuto::EnFlux
+  READS:    EulerAuto::Enrhs
+  READS:    EulerAuto::S1Flux
+  READS:    EulerAuto::S1rhs
+  READS:    EulerAuto::S2Flux
+  READS:    EulerAuto::S2rhs
+  READS:    EulerAuto::S3Flux
+  READS:    EulerAuto::S3rhs
+  WRITES:   EulerAuto::Denrhs
+  WRITES:   EulerAuto::Enrhs
+  WRITES:   EulerAuto::S1rhs
+  WRITES:   EulerAuto::S2rhs
+  WRITES:   EulerAuto::S3rhs
 } "eulerauto_cons_calc_rhs_1"
 
 schedule group eulerauto_cons_calc_reconstruct_2_group in MoL_CalcRHS after eulerauto_cons_calc_rhs_1
@@ -301,6 +401,21 @@ schedule group eulerauto_cons_calc_reconstruct_2_group in MoL_CalcRHS after eule
 schedule eulerauto_cons_calc_reconstruct_2 in eulerauto_cons_calc_reconstruct_2_group
 {
   LANG: C
+  READS:    EulerAuto::p
+  READS:    EulerAuto::rho
+  READS:    EulerAuto::v1
+  READS:    EulerAuto::v2
+  READS:    EulerAuto::v3
+  WRITES:   EulerAuto::pLeft
+  WRITES:   EulerAuto::pRight
+  WRITES:   EulerAuto::rhoLeft
+  WRITES:   EulerAuto::rhoRight
+  WRITES:   EulerAuto::v1Left
+  WRITES:   EulerAuto::v1Right
+  WRITES:   EulerAuto::v2Left
+  WRITES:   EulerAuto::v2Right
+  WRITES:   EulerAuto::v3Left
+  WRITES:   EulerAuto::v3Right
 } "eulerauto_cons_calc_reconstruct_2"
 
 schedule eulerauto_cons_calc_reconstruct_2_SelectBCs in eulerauto_cons_calc_reconstruct_2_bc_group
@@ -332,6 +447,26 @@ schedule group eulerauto_cons_calc_reconstruct_2_bc_group in MoL_PseudoEvolution
 schedule eulerauto_cons_calc_intercell_conserved_2 in MoL_CalcRHS after eulerauto_cons_calc_reconstruct_2
 {
   LANG: C
+  READS:    EulerAuto::pLeft
+  READS:    EulerAuto::pRight
+  READS:    EulerAuto::rhoLeft
+  READS:    EulerAuto::rhoRight
+  READS:    EulerAuto::v1Left
+  READS:    EulerAuto::v1Right
+  READS:    EulerAuto::v2Left
+  READS:    EulerAuto::v2Right
+  READS:    EulerAuto::v3Left
+  READS:    EulerAuto::v3Right
+  WRITES:   EulerAuto::DenLeft
+  WRITES:   EulerAuto::DenRight
+  WRITES:   EulerAuto::EnLeft
+  WRITES:   EulerAuto::EnRight
+  WRITES:   EulerAuto::S1Left
+  WRITES:   EulerAuto::S1Right
+  WRITES:   EulerAuto::S2Left
+  WRITES:   EulerAuto::S2Right
+  WRITES:   EulerAuto::S3Left
+  WRITES:   EulerAuto::S3Right
 } "eulerauto_cons_calc_intercell_conserved_2"
 
 schedule group eulerauto_cons_calc_flux_2_group in MoL_CalcRHS after eulerauto_cons_calc_intercell_conserved_2
@@ -342,6 +477,31 @@ schedule group eulerauto_cons_calc_flux_2_group in MoL_CalcRHS after eulerauto_c
 schedule eulerauto_cons_calc_flux_2 in eulerauto_cons_calc_flux_2_group
 {
   LANG: C
+  READS:    EulerAuto::DenLeft
+  READS:    EulerAuto::DenRight
+  READS:    EulerAuto::EnLeft
+  READS:    EulerAuto::EnRight
+  READS:    EulerAuto::pLeft
+  READS:    EulerAuto::pRight
+  READS:    EulerAuto::rhoLeft
+  READS:    EulerAuto::rhoRight
+  READS:    EulerAuto::S1Left
+  READS:    EulerAuto::S1Right
+  READS:    EulerAuto::S2Left
+  READS:    EulerAuto::S2Right
+  READS:    EulerAuto::S3Left
+  READS:    EulerAuto::S3Right
+  READS:    EulerAuto::v1Left
+  READS:    EulerAuto::v1Right
+  READS:    EulerAuto::v2Left
+  READS:    EulerAuto::v2Right
+  READS:    EulerAuto::v3Left
+  READS:    EulerAuto::v3Right
+  WRITES:   EulerAuto::DenFlux
+  WRITES:   EulerAuto::EnFlux
+  WRITES:   EulerAuto::S1Flux
+  WRITES:   EulerAuto::S2Flux
+  WRITES:   EulerAuto::S3Flux
 } "eulerauto_cons_calc_flux_2"
 
 schedule eulerauto_cons_calc_flux_2_SelectBCs in eulerauto_cons_calc_flux_2_bc_group
@@ -373,6 +533,21 @@ schedule group eulerauto_cons_calc_flux_2_bc_group in MoL_PseudoEvolutionBoundar
 schedule eulerauto_cons_calc_rhs_2 in MoL_CalcRHS after eulerauto_cons_calc_flux_2
 {
   LANG: C
+  READS:    EulerAuto::DenFlux
+  READS:    EulerAuto::Denrhs
+  READS:    EulerAuto::EnFlux
+  READS:    EulerAuto::Enrhs
+  READS:    EulerAuto::S1Flux
+  READS:    EulerAuto::S1rhs
+  READS:    EulerAuto::S2Flux
+  READS:    EulerAuto::S2rhs
+  READS:    EulerAuto::S3Flux
+  READS:    EulerAuto::S3rhs
+  WRITES:   EulerAuto::Denrhs
+  WRITES:   EulerAuto::Enrhs
+  WRITES:   EulerAuto::S1rhs
+  WRITES:   EulerAuto::S2rhs
+  WRITES:   EulerAuto::S3rhs
 } "eulerauto_cons_calc_rhs_2"
 
 schedule group eulerauto_cons_calc_reconstruct_3_group in MoL_CalcRHS after eulerauto_cons_calc_rhs_2
@@ -383,6 +558,21 @@ schedule group eulerauto_cons_calc_reconstruct_3_group in MoL_CalcRHS after eule
 schedule eulerauto_cons_calc_reconstruct_3 in eulerauto_cons_calc_reconstruct_3_group
 {
   LANG: C
+  READS:    EulerAuto::p
+  READS:    EulerAuto::rho
+  READS:    EulerAuto::v1
+  READS:    EulerAuto::v2
+  READS:    EulerAuto::v3
+  WRITES:   EulerAuto::pLeft
+  WRITES:   EulerAuto::pRight
+  WRITES:   EulerAuto::rhoLeft
+  WRITES:   EulerAuto::rhoRight
+  WRITES:   EulerAuto::v1Left
+  WRITES:   EulerAuto::v1Right
+  WRITES:   EulerAuto::v2Left
+  WRITES:   EulerAuto::v2Right
+  WRITES:   EulerAuto::v3Left
+  WRITES:   EulerAuto::v3Right
 } "eulerauto_cons_calc_reconstruct_3"
 
 schedule eulerauto_cons_calc_reconstruct_3_SelectBCs in eulerauto_cons_calc_reconstruct_3_bc_group
@@ -414,6 +604,26 @@ schedule group eulerauto_cons_calc_reconstruct_3_bc_group in MoL_PseudoEvolution
 schedule eulerauto_cons_calc_intercell_conserved_3 in MoL_CalcRHS after eulerauto_cons_calc_reconstruct_3
 {
   LANG: C
+  READS:    EulerAuto::pLeft
+  READS:    EulerAuto::pRight
+  READS:    EulerAuto::rhoLeft
+  READS:    EulerAuto::rhoRight
+  READS:    EulerAuto::v1Left
+  READS:    EulerAuto::v1Right
+  READS:    EulerAuto::v2Left
+  READS:    EulerAuto::v2Right
+  READS:    EulerAuto::v3Left
+  READS:    EulerAuto::v3Right
+  WRITES:   EulerAuto::DenLeft
+  WRITES:   EulerAuto::DenRight
+  WRITES:   EulerAuto::EnLeft
+  WRITES:   EulerAuto::EnRight
+  WRITES:   EulerAuto::S1Left
+  WRITES:   EulerAuto::S1Right
+  WRITES:   EulerAuto::S2Left
+  WRITES:   EulerAuto::S2Right
+  WRITES:   EulerAuto::S3Left
+  WRITES:   EulerAuto::S3Right
 } "eulerauto_cons_calc_intercell_conserved_3"
 
 schedule group eulerauto_cons_calc_flux_3_group in MoL_CalcRHS after eulerauto_cons_calc_intercell_conserved_3
@@ -424,6 +634,31 @@ schedule group eulerauto_cons_calc_flux_3_group in MoL_CalcRHS after eulerauto_c
 schedule eulerauto_cons_calc_flux_3 in eulerauto_cons_calc_flux_3_group
 {
   LANG: C
+  READS:    EulerAuto::DenLeft
+  READS:    EulerAuto::DenRight
+  READS:    EulerAuto::EnLeft
+  READS:    EulerAuto::EnRight
+  READS:    EulerAuto::pLeft
+  READS:    EulerAuto::pRight
+  READS:    EulerAuto::rhoLeft
+  READS:    EulerAuto::rhoRight
+  READS:    EulerAuto::S1Left
+  READS:    EulerAuto::S1Right
+  READS:    EulerAuto::S2Left
+  READS:    EulerAuto::S2Right
+  READS:    EulerAuto::S3Left
+  READS:    EulerAuto::S3Right
+  READS:    EulerAuto::v1Left
+  READS:    EulerAuto::v1Right
+  READS:    EulerAuto::v2Left
+  READS:    EulerAuto::v2Right
+  READS:    EulerAuto::v3Left
+  READS:    EulerAuto::v3Right
+  WRITES:   EulerAuto::DenFlux
+  WRITES:   EulerAuto::EnFlux
+  WRITES:   EulerAuto::S1Flux
+  WRITES:   EulerAuto::S2Flux
+  WRITES:   EulerAuto::S3Flux
 } "eulerauto_cons_calc_flux_3"
 
 schedule eulerauto_cons_calc_flux_3_SelectBCs in eulerauto_cons_calc_flux_3_bc_group
@@ -455,6 +690,21 @@ schedule group eulerauto_cons_calc_flux_3_bc_group in MoL_PseudoEvolutionBoundar
 schedule eulerauto_cons_calc_rhs_3 in MoL_CalcRHS after eulerauto_cons_calc_flux_3
 {
   LANG: C
+  READS:    EulerAuto::DenFlux
+  READS:    EulerAuto::Denrhs
+  READS:    EulerAuto::EnFlux
+  READS:    EulerAuto::Enrhs
+  READS:    EulerAuto::S1Flux
+  READS:    EulerAuto::S1rhs
+  READS:    EulerAuto::S2Flux
+  READS:    EulerAuto::S2rhs
+  READS:    EulerAuto::S3Flux
+  READS:    EulerAuto::S3rhs
+  WRITES:   EulerAuto::Denrhs
+  WRITES:   EulerAuto::Enrhs
+  WRITES:   EulerAuto::S1rhs
+  WRITES:   EulerAuto::S2rhs
+  WRITES:   EulerAuto::S3rhs
 } "eulerauto_cons_calc_rhs_3"
 
 schedule EulerAuto_SelectBoundConds in MoL_PostStep
@@ -472,6 +722,12 @@ schedule EulerAuto_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
+schedule EulerAuto_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
 schedule group ApplyBCs as EulerAuto_ApplyBCs in MoL_PostStep after EulerAuto_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_conserved.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_conserved.cc
index b41803a..9696876 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_conserved.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_conserved.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulerauto_cons_calc_conserved_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulerauto_cons_calc_conserved_Body(cGH const * restrict const cctkGH
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulerauto_cons_calc_conserved_Body(cGH const * restrict const cctkGH
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_conserved,
+  CCTK_LOOP3(eulerauto_cons_calc_conserved,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -110,7 +108,7 @@ static void eulerauto_cons_calc_conserved_Body(cGH const * restrict const cctkGH
     S2[index] = S2L;
     S3[index] = S3L;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_conserved);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_conserved);
 }
 
 extern "C" void eulerauto_cons_calc_conserved(CCTK_ARGUMENTS)
@@ -129,11 +127,17 @@ extern "C" void eulerauto_cons_calc_conserved(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_group","EulerAuto::En_group","EulerAuto::p_group","EulerAuto::rho_group","EulerAuto::S_group","EulerAuto::v_group"};
+  const char *const groups[] = {
+    "EulerAuto::Den_group",
+    "EulerAuto::En_group",
+    "EulerAuto::p_group",
+    "EulerAuto::rho_group",
+    "EulerAuto::S_group",
+    "EulerAuto::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_conserved", 6, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulerauto_cons_calc_conserved_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulerauto_cons_calc_conserved_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_flux_1.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_flux_1.cc
index 02eec61..01c2e08 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_flux_1.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_flux_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulerauto_cons_calc_flux_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulerauto_cons_calc_flux_1_Body(cGH const * restrict const cctkGH, i
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulerauto_cons_calc_flux_1_Body(cGH const * restrict const cctkGH, i
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_flux_1,
+  CCTK_LOOP3(eulerauto_cons_calc_flux_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -187,7 +185,7 @@ static void eulerauto_cons_calc_flux_1_Body(cGH const * restrict const cctkGH, i
     S2Flux[index] = S2FluxL;
     S3Flux[index] = S3FluxL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_flux_1);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_flux_1);
 }
 
 extern "C" void eulerauto_cons_calc_flux_1(CCTK_ARGUMENTS)
@@ -206,12 +204,27 @@ extern "C" void eulerauto_cons_calc_flux_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_flux_group","EulerAuto::Den_lr_group","EulerAuto::En_flux_group","EulerAuto::En_lr_group","EulerAuto::p_lr_group","EulerAuto::rho_lr_group","EulerAuto::S1_flux_group","EulerAuto::S1_lr_group","EulerAuto::S2_flux_group","EulerAuto::S2_lr_group","EulerAuto::S3_flux_group","EulerAuto::S3_lr_group","EulerAuto::v1_lr_group","EulerAuto::v2_lr_group","EulerAuto::v3_lr_group"};
+  const char *const groups[] = {
+    "EulerAuto::Den_flux_group",
+    "EulerAuto::Den_lr_group",
+    "EulerAuto::En_flux_group",
+    "EulerAuto::En_lr_group",
+    "EulerAuto::p_lr_group",
+    "EulerAuto::rho_lr_group",
+    "EulerAuto::S1_flux_group",
+    "EulerAuto::S1_lr_group",
+    "EulerAuto::S2_flux_group",
+    "EulerAuto::S2_lr_group",
+    "EulerAuto::S3_flux_group",
+    "EulerAuto::S3_lr_group",
+    "EulerAuto::v1_lr_group",
+    "EulerAuto::v2_lr_group",
+    "EulerAuto::v3_lr_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_flux_1", 15, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulerauto_cons_calc_flux_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulerauto_cons_calc_flux_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulerauto_cons_calc_flux_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_flux_2.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_flux_2.cc
index eb6fac5..8ad72ef 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_flux_2.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_flux_2.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulerauto_cons_calc_flux_2_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulerauto_cons_calc_flux_2_Body(cGH const * restrict const cctkGH, i
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulerauto_cons_calc_flux_2_Body(cGH const * restrict const cctkGH, i
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_flux_2,
+  CCTK_LOOP3(eulerauto_cons_calc_flux_2,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -187,7 +185,7 @@ static void eulerauto_cons_calc_flux_2_Body(cGH const * restrict const cctkGH, i
     S2Flux[index] = S2FluxL;
     S3Flux[index] = S3FluxL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_flux_2);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_flux_2);
 }
 
 extern "C" void eulerauto_cons_calc_flux_2(CCTK_ARGUMENTS)
@@ -206,12 +204,27 @@ extern "C" void eulerauto_cons_calc_flux_2(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_flux_group","EulerAuto::Den_lr_group","EulerAuto::En_flux_group","EulerAuto::En_lr_group","EulerAuto::p_lr_group","EulerAuto::rho_lr_group","EulerAuto::S1_flux_group","EulerAuto::S1_lr_group","EulerAuto::S2_flux_group","EulerAuto::S2_lr_group","EulerAuto::S3_flux_group","EulerAuto::S3_lr_group","EulerAuto::v1_lr_group","EulerAuto::v2_lr_group","EulerAuto::v3_lr_group"};
+  const char *const groups[] = {
+    "EulerAuto::Den_flux_group",
+    "EulerAuto::Den_lr_group",
+    "EulerAuto::En_flux_group",
+    "EulerAuto::En_lr_group",
+    "EulerAuto::p_lr_group",
+    "EulerAuto::rho_lr_group",
+    "EulerAuto::S1_flux_group",
+    "EulerAuto::S1_lr_group",
+    "EulerAuto::S2_flux_group",
+    "EulerAuto::S2_lr_group",
+    "EulerAuto::S3_flux_group",
+    "EulerAuto::S3_lr_group",
+    "EulerAuto::v1_lr_group",
+    "EulerAuto::v2_lr_group",
+    "EulerAuto::v3_lr_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_flux_2", 15, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulerauto_cons_calc_flux_2", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulerauto_cons_calc_flux_2_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulerauto_cons_calc_flux_2_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_flux_3.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_flux_3.cc
index 140cd47..752fec3 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_flux_3.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_flux_3.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulerauto_cons_calc_flux_3_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulerauto_cons_calc_flux_3_Body(cGH const * restrict const cctkGH, i
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulerauto_cons_calc_flux_3_Body(cGH const * restrict const cctkGH, i
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_flux_3,
+  CCTK_LOOP3(eulerauto_cons_calc_flux_3,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -187,7 +185,7 @@ static void eulerauto_cons_calc_flux_3_Body(cGH const * restrict const cctkGH, i
     S2Flux[index] = S2FluxL;
     S3Flux[index] = S3FluxL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_flux_3);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_flux_3);
 }
 
 extern "C" void eulerauto_cons_calc_flux_3(CCTK_ARGUMENTS)
@@ -206,12 +204,27 @@ extern "C" void eulerauto_cons_calc_flux_3(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_flux_group","EulerAuto::Den_lr_group","EulerAuto::En_flux_group","EulerAuto::En_lr_group","EulerAuto::p_lr_group","EulerAuto::rho_lr_group","EulerAuto::S1_flux_group","EulerAuto::S1_lr_group","EulerAuto::S2_flux_group","EulerAuto::S2_lr_group","EulerAuto::S3_flux_group","EulerAuto::S3_lr_group","EulerAuto::v1_lr_group","EulerAuto::v2_lr_group","EulerAuto::v3_lr_group"};
+  const char *const groups[] = {
+    "EulerAuto::Den_flux_group",
+    "EulerAuto::Den_lr_group",
+    "EulerAuto::En_flux_group",
+    "EulerAuto::En_lr_group",
+    "EulerAuto::p_lr_group",
+    "EulerAuto::rho_lr_group",
+    "EulerAuto::S1_flux_group",
+    "EulerAuto::S1_lr_group",
+    "EulerAuto::S2_flux_group",
+    "EulerAuto::S2_lr_group",
+    "EulerAuto::S3_flux_group",
+    "EulerAuto::S3_lr_group",
+    "EulerAuto::v1_lr_group",
+    "EulerAuto::v2_lr_group",
+    "EulerAuto::v3_lr_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_flux_3", 15, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulerauto_cons_calc_flux_3", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulerauto_cons_calc_flux_3_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulerauto_cons_calc_flux_3_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_1.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_1.cc
index fdcd6f7..6f22748 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_1.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulerauto_cons_calc_intercell_conserved_1_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulerauto_cons_calc_intercell_conserved_1_Body(cGH const * restrict
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulerauto_cons_calc_intercell_conserved_1_Body(cGH const * restrict
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_intercell_conserved_1,
+  CCTK_LOOP3(eulerauto_cons_calc_intercell_conserved_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -133,7 +131,7 @@ static void eulerauto_cons_calc_intercell_conserved_1_Body(cGH const * restrict
     S3Left[index] = S3LeftL;
     S3Right[index] = S3RightL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_intercell_conserved_1);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_intercell_conserved_1);
 }
 
 extern "C" void eulerauto_cons_calc_intercell_conserved_1(CCTK_ARGUMENTS)
@@ -152,11 +150,21 @@ extern "C" void eulerauto_cons_calc_intercell_conserved_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_lr_group","EulerAuto::En_lr_group","EulerAuto::p_lr_group","EulerAuto::rho_lr_group","EulerAuto::S1_lr_group","EulerAuto::S2_lr_group","EulerAuto::S3_lr_group","EulerAuto::v1_lr_group","EulerAuto::v2_lr_group","EulerAuto::v3_lr_group"};
+  const char *const groups[] = {
+    "EulerAuto::Den_lr_group",
+    "EulerAuto::En_lr_group",
+    "EulerAuto::p_lr_group",
+    "EulerAuto::rho_lr_group",
+    "EulerAuto::S1_lr_group",
+    "EulerAuto::S2_lr_group",
+    "EulerAuto::S3_lr_group",
+    "EulerAuto::v1_lr_group",
+    "EulerAuto::v2_lr_group",
+    "EulerAuto::v3_lr_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_intercell_conserved_1", 10, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulerauto_cons_calc_intercell_conserved_1_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulerauto_cons_calc_intercell_conserved_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_2.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_2.cc
index 9a8709d..3d9488e 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_2.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_2.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulerauto_cons_calc_intercell_conserved_2_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulerauto_cons_calc_intercell_conserved_2_Body(cGH const * restrict
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulerauto_cons_calc_intercell_conserved_2_Body(cGH const * restrict
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_intercell_conserved_2,
+  CCTK_LOOP3(eulerauto_cons_calc_intercell_conserved_2,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -133,7 +131,7 @@ static void eulerauto_cons_calc_intercell_conserved_2_Body(cGH const * restrict
     S3Left[index] = S3LeftL;
     S3Right[index] = S3RightL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_intercell_conserved_2);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_intercell_conserved_2);
 }
 
 extern "C" void eulerauto_cons_calc_intercell_conserved_2(CCTK_ARGUMENTS)
@@ -152,11 +150,21 @@ extern "C" void eulerauto_cons_calc_intercell_conserved_2(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_lr_group","EulerAuto::En_lr_group","EulerAuto::p_lr_group","EulerAuto::rho_lr_group","EulerAuto::S1_lr_group","EulerAuto::S2_lr_group","EulerAuto::S3_lr_group","EulerAuto::v1_lr_group","EulerAuto::v2_lr_group","EulerAuto::v3_lr_group"};
+  const char *const groups[] = {
+    "EulerAuto::Den_lr_group",
+    "EulerAuto::En_lr_group",
+    "EulerAuto::p_lr_group",
+    "EulerAuto::rho_lr_group",
+    "EulerAuto::S1_lr_group",
+    "EulerAuto::S2_lr_group",
+    "EulerAuto::S3_lr_group",
+    "EulerAuto::v1_lr_group",
+    "EulerAuto::v2_lr_group",
+    "EulerAuto::v3_lr_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_intercell_conserved_2", 10, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulerauto_cons_calc_intercell_conserved_2_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulerauto_cons_calc_intercell_conserved_2_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_3.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_3.cc
index 2c4f3a1..096f13c 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_3.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_intercell_conserved_3.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulerauto_cons_calc_intercell_conserved_3_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulerauto_cons_calc_intercell_conserved_3_Body(cGH const * restrict
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulerauto_cons_calc_intercell_conserved_3_Body(cGH const * restrict
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_intercell_conserved_3,
+  CCTK_LOOP3(eulerauto_cons_calc_intercell_conserved_3,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -133,7 +131,7 @@ static void eulerauto_cons_calc_intercell_conserved_3_Body(cGH const * restrict
     S3Left[index] = S3LeftL;
     S3Right[index] = S3RightL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_intercell_conserved_3);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_intercell_conserved_3);
 }
 
 extern "C" void eulerauto_cons_calc_intercell_conserved_3(CCTK_ARGUMENTS)
@@ -152,11 +150,21 @@ extern "C" void eulerauto_cons_calc_intercell_conserved_3(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_lr_group","EulerAuto::En_lr_group","EulerAuto::p_lr_group","EulerAuto::rho_lr_group","EulerAuto::S1_lr_group","EulerAuto::S2_lr_group","EulerAuto::S3_lr_group","EulerAuto::v1_lr_group","EulerAuto::v2_lr_group","EulerAuto::v3_lr_group"};
+  const char *const groups[] = {
+    "EulerAuto::Den_lr_group",
+    "EulerAuto::En_lr_group",
+    "EulerAuto::p_lr_group",
+    "EulerAuto::rho_lr_group",
+    "EulerAuto::S1_lr_group",
+    "EulerAuto::S2_lr_group",
+    "EulerAuto::S3_lr_group",
+    "EulerAuto::v1_lr_group",
+    "EulerAuto::v2_lr_group",
+    "EulerAuto::v3_lr_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_intercell_conserved_3", 10, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulerauto_cons_calc_intercell_conserved_3_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulerauto_cons_calc_intercell_conserved_3_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_primitives.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_primitives.cc
index 1b16069..b2cafeb 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_primitives.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_primitives.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulerauto_cons_calc_primitives_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulerauto_cons_calc_primitives_Body(cGH const * restrict const cctkG
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulerauto_cons_calc_primitives_Body(cGH const * restrict const cctkG
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_primitives,
+  CCTK_LOOP3(eulerauto_cons_calc_primitives,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -110,7 +108,7 @@ static void eulerauto_cons_calc_primitives_Body(cGH const * restrict const cctkG
     v2[index] = v2L;
     v3[index] = v3L;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_primitives);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_primitives);
 }
 
 extern "C" void eulerauto_cons_calc_primitives(CCTK_ARGUMENTS)
@@ -129,11 +127,17 @@ extern "C" void eulerauto_cons_calc_primitives(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_group","EulerAuto::En_group","EulerAuto::p_group","EulerAuto::rho_group","EulerAuto::S_group","EulerAuto::v_group"};
+  const char *const groups[] = {
+    "EulerAuto::Den_group",
+    "EulerAuto::En_group",
+    "EulerAuto::p_group",
+    "EulerAuto::rho_group",
+    "EulerAuto::S_group",
+    "EulerAuto::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_primitives", 6, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulerauto_cons_calc_primitives_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulerauto_cons_calc_primitives_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_1.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_1.cc
index be96c9f..f0dbe5f 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_1.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulerauto_cons_calc_reconstruct_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulerauto_cons_calc_reconstruct_1_Body(cGH const * restrict const cc
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulerauto_cons_calc_reconstruct_1_Body(cGH const * restrict const cc
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_reconstruct_1,
+  CCTK_LOOP3(eulerauto_cons_calc_reconstruct_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -188,7 +186,7 @@ static void eulerauto_cons_calc_reconstruct_1_Body(cGH const * restrict const cc
     v3Left[index] = v3LeftL;
     v3Right[index] = v3RightL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_reconstruct_1);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_reconstruct_1);
 }
 
 extern "C" void eulerauto_cons_calc_reconstruct_1(CCTK_ARGUMENTS)
@@ -207,12 +205,20 @@ extern "C" void eulerauto_cons_calc_reconstruct_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::p_group","EulerAuto::p_lr_group","EulerAuto::rho_group","EulerAuto::rho_lr_group","EulerAuto::v1_lr_group","EulerAuto::v2_lr_group","EulerAuto::v3_lr_group","EulerAuto::v_group"};
+  const char *const groups[] = {
+    "EulerAuto::p_group",
+    "EulerAuto::p_lr_group",
+    "EulerAuto::rho_group",
+    "EulerAuto::rho_lr_group",
+    "EulerAuto::v1_lr_group",
+    "EulerAuto::v2_lr_group",
+    "EulerAuto::v3_lr_group",
+    "EulerAuto::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_reconstruct_1", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulerauto_cons_calc_reconstruct_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulerauto_cons_calc_reconstruct_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulerauto_cons_calc_reconstruct_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_2.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_2.cc
index 34b7f55..f47b0d7 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_2.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_2.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulerauto_cons_calc_reconstruct_2_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulerauto_cons_calc_reconstruct_2_Body(cGH const * restrict const cc
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulerauto_cons_calc_reconstruct_2_Body(cGH const * restrict const cc
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_reconstruct_2,
+  CCTK_LOOP3(eulerauto_cons_calc_reconstruct_2,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -188,7 +186,7 @@ static void eulerauto_cons_calc_reconstruct_2_Body(cGH const * restrict const cc
     v3Left[index] = v3LeftL;
     v3Right[index] = v3RightL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_reconstruct_2);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_reconstruct_2);
 }
 
 extern "C" void eulerauto_cons_calc_reconstruct_2(CCTK_ARGUMENTS)
@@ -207,12 +205,20 @@ extern "C" void eulerauto_cons_calc_reconstruct_2(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::p_group","EulerAuto::p_lr_group","EulerAuto::rho_group","EulerAuto::rho_lr_group","EulerAuto::v1_lr_group","EulerAuto::v2_lr_group","EulerAuto::v3_lr_group","EulerAuto::v_group"};
+  const char *const groups[] = {
+    "EulerAuto::p_group",
+    "EulerAuto::p_lr_group",
+    "EulerAuto::rho_group",
+    "EulerAuto::rho_lr_group",
+    "EulerAuto::v1_lr_group",
+    "EulerAuto::v2_lr_group",
+    "EulerAuto::v3_lr_group",
+    "EulerAuto::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_reconstruct_2", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulerauto_cons_calc_reconstruct_2", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulerauto_cons_calc_reconstruct_2_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulerauto_cons_calc_reconstruct_2_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_3.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_3.cc
index 5481fba..3075063 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_3.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_reconstruct_3.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulerauto_cons_calc_reconstruct_3_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulerauto_cons_calc_reconstruct_3_Body(cGH const * restrict const cc
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulerauto_cons_calc_reconstruct_3_Body(cGH const * restrict const cc
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_reconstruct_3,
+  CCTK_LOOP3(eulerauto_cons_calc_reconstruct_3,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -188,7 +186,7 @@ static void eulerauto_cons_calc_reconstruct_3_Body(cGH const * restrict const cc
     v3Left[index] = v3LeftL;
     v3Right[index] = v3RightL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_reconstruct_3);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_reconstruct_3);
 }
 
 extern "C" void eulerauto_cons_calc_reconstruct_3(CCTK_ARGUMENTS)
@@ -207,12 +205,20 @@ extern "C" void eulerauto_cons_calc_reconstruct_3(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::p_group","EulerAuto::p_lr_group","EulerAuto::rho_group","EulerAuto::rho_lr_group","EulerAuto::v1_lr_group","EulerAuto::v2_lr_group","EulerAuto::v3_lr_group","EulerAuto::v_group"};
+  const char *const groups[] = {
+    "EulerAuto::p_group",
+    "EulerAuto::p_lr_group",
+    "EulerAuto::rho_group",
+    "EulerAuto::rho_lr_group",
+    "EulerAuto::v1_lr_group",
+    "EulerAuto::v2_lr_group",
+    "EulerAuto::v3_lr_group",
+    "EulerAuto::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_reconstruct_3", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulerauto_cons_calc_reconstruct_3", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulerauto_cons_calc_reconstruct_3_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulerauto_cons_calc_reconstruct_3_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_1.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_1.cc
index 5f38d60..5f1e9ed 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_1.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulerauto_cons_calc_rhs_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -46,8 +46,6 @@ static void eulerauto_cons_calc_rhs_1_Body(cGH const * restrict const cctkGH, in
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -90,9 +88,9 @@ static void eulerauto_cons_calc_rhs_1_Body(cGH const * restrict const cctkGH, in
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_rhs_1,
+  CCTK_LOOP3(eulerauto_cons_calc_rhs_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -137,7 +135,7 @@ static void eulerauto_cons_calc_rhs_1_Body(cGH const * restrict const cctkGH, in
     S2rhs[index] = S2rhsL;
     S3rhs[index] = S3rhsL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_rhs_1);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_rhs_1);
 }
 
 extern "C" void eulerauto_cons_calc_rhs_1(CCTK_ARGUMENTS)
@@ -156,12 +154,20 @@ extern "C" void eulerauto_cons_calc_rhs_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_flux_group","EulerAuto::Den_grouprhs","EulerAuto::En_flux_group","EulerAuto::En_grouprhs","EulerAuto::S1_flux_group","EulerAuto::S2_flux_group","EulerAuto::S3_flux_group","EulerAuto::S_grouprhs"};
+  const char *const groups[] = {
+    "EulerAuto::Den_flux_group",
+    "EulerAuto::Den_grouprhs",
+    "EulerAuto::En_flux_group",
+    "EulerAuto::En_grouprhs",
+    "EulerAuto::S1_flux_group",
+    "EulerAuto::S2_flux_group",
+    "EulerAuto::S3_flux_group",
+    "EulerAuto::S_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_rhs_1", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulerauto_cons_calc_rhs_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulerauto_cons_calc_rhs_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulerauto_cons_calc_rhs_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_2.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_2.cc
index c4859bc..796a85b 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_2.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_2.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulerauto_cons_calc_rhs_2_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -46,8 +46,6 @@ static void eulerauto_cons_calc_rhs_2_Body(cGH const * restrict const cctkGH, in
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -90,9 +88,9 @@ static void eulerauto_cons_calc_rhs_2_Body(cGH const * restrict const cctkGH, in
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_rhs_2,
+  CCTK_LOOP3(eulerauto_cons_calc_rhs_2,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -137,7 +135,7 @@ static void eulerauto_cons_calc_rhs_2_Body(cGH const * restrict const cctkGH, in
     S2rhs[index] = S2rhsL;
     S3rhs[index] = S3rhsL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_rhs_2);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_rhs_2);
 }
 
 extern "C" void eulerauto_cons_calc_rhs_2(CCTK_ARGUMENTS)
@@ -156,12 +154,20 @@ extern "C" void eulerauto_cons_calc_rhs_2(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_flux_group","EulerAuto::Den_grouprhs","EulerAuto::En_flux_group","EulerAuto::En_grouprhs","EulerAuto::S1_flux_group","EulerAuto::S2_flux_group","EulerAuto::S3_flux_group","EulerAuto::S_grouprhs"};
+  const char *const groups[] = {
+    "EulerAuto::Den_flux_group",
+    "EulerAuto::Den_grouprhs",
+    "EulerAuto::En_flux_group",
+    "EulerAuto::En_grouprhs",
+    "EulerAuto::S1_flux_group",
+    "EulerAuto::S2_flux_group",
+    "EulerAuto::S3_flux_group",
+    "EulerAuto::S_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_rhs_2", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulerauto_cons_calc_rhs_2", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulerauto_cons_calc_rhs_2_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulerauto_cons_calc_rhs_2_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_3.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_3.cc
index 0ce65f6..3aca46c 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_3.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_rhs_3.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulerauto_cons_calc_rhs_3_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -46,8 +46,6 @@ static void eulerauto_cons_calc_rhs_3_Body(cGH const * restrict const cctkGH, in
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -90,9 +88,9 @@ static void eulerauto_cons_calc_rhs_3_Body(cGH const * restrict const cctkGH, in
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_rhs_3,
+  CCTK_LOOP3(eulerauto_cons_calc_rhs_3,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -137,7 +135,7 @@ static void eulerauto_cons_calc_rhs_3_Body(cGH const * restrict const cctkGH, in
     S2rhs[index] = S2rhsL;
     S3rhs[index] = S3rhsL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_rhs_3);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_rhs_3);
 }
 
 extern "C" void eulerauto_cons_calc_rhs_3(CCTK_ARGUMENTS)
@@ -156,12 +154,20 @@ extern "C" void eulerauto_cons_calc_rhs_3(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_flux_group","EulerAuto::Den_grouprhs","EulerAuto::En_flux_group","EulerAuto::En_grouprhs","EulerAuto::S1_flux_group","EulerAuto::S2_flux_group","EulerAuto::S3_flux_group","EulerAuto::S_grouprhs"};
+  const char *const groups[] = {
+    "EulerAuto::Den_flux_group",
+    "EulerAuto::Den_grouprhs",
+    "EulerAuto::En_flux_group",
+    "EulerAuto::En_grouprhs",
+    "EulerAuto::S1_flux_group",
+    "EulerAuto::S2_flux_group",
+    "EulerAuto::S3_flux_group",
+    "EulerAuto::S_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_rhs_3", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulerauto_cons_calc_rhs_3", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulerauto_cons_calc_rhs_3_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulerauto_cons_calc_rhs_3_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_cons_calc_zero_rhs.cc b/Examples/EulerAuto/src/eulerauto_cons_calc_zero_rhs.cc
index 5418435..267d6c6 100644
--- a/Examples/EulerAuto/src/eulerauto_cons_calc_zero_rhs.cc
+++ b/Examples/EulerAuto/src/eulerauto_cons_calc_zero_rhs.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulerauto_cons_calc_zero_rhs_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulerauto_cons_calc_zero_rhs_Body(cGH const * restrict const cctkGH,
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulerauto_cons_calc_zero_rhs_Body(cGH const * restrict const cctkGH,
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_cons_calc_zero_rhs,
+  CCTK_LOOP3(eulerauto_cons_calc_zero_rhs,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -124,7 +122,7 @@ static void eulerauto_cons_calc_zero_rhs_Body(cGH const * restrict const cctkGH,
     S2rhs[index] = S2rhsL;
     S3rhs[index] = S3rhsL;
   }
-  CCTK_ENDLOOP3 (eulerauto_cons_calc_zero_rhs);
+  CCTK_ENDLOOP3(eulerauto_cons_calc_zero_rhs);
 }
 
 extern "C" void eulerauto_cons_calc_zero_rhs(CCTK_ARGUMENTS)
@@ -143,11 +141,14 @@ extern "C" void eulerauto_cons_calc_zero_rhs(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerAuto::Den_grouprhs","EulerAuto::En_grouprhs","EulerAuto::S_grouprhs"};
+  const char *const groups[] = {
+    "EulerAuto::Den_grouprhs",
+    "EulerAuto::En_grouprhs",
+    "EulerAuto::S_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_cons_calc_zero_rhs", 3, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulerauto_cons_calc_zero_rhs_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulerauto_cons_calc_zero_rhs_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/eulerauto_initial_shock.cc b/Examples/EulerAuto/src/eulerauto_initial_shock.cc
index ea1b342..3becd2f 100644
--- a/Examples/EulerAuto/src/eulerauto_initial_shock.cc
+++ b/Examples/EulerAuto/src/eulerauto_initial_shock.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulerauto_initial_shock_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulerauto_initial_shock_Body(cGH const * restrict const cctkGH, int
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulerauto_initial_shock_Body(cGH const * restrict const cctkGH, int
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulerauto_initial_shock,
+  CCTK_LOOP3(eulerauto_initial_shock,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -108,7 +106,7 @@ static void eulerauto_initial_shock_Body(cGH const * restrict const cctkGH, int
     v2[index] = v2L;
     v3[index] = v3L;
   }
-  CCTK_ENDLOOP3 (eulerauto_initial_shock);
+  CCTK_ENDLOOP3(eulerauto_initial_shock);
 }
 
 extern "C" void eulerauto_initial_shock(CCTK_ARGUMENTS)
@@ -127,11 +125,15 @@ extern "C" void eulerauto_initial_shock(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"grid::coordinates","EulerAuto::p_group","EulerAuto::rho_group","EulerAuto::v_group"};
+  const char *const groups[] = {
+    "grid::coordinates",
+    "EulerAuto::p_group",
+    "EulerAuto::rho_group",
+    "EulerAuto::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulerauto_initial_shock", 4, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulerauto_initial_shock_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulerauto_initial_shock_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerAuto/src/make.code.defn b/Examples/EulerAuto/src/make.code.defn
index 0e17ddb..c79c855 100644
--- a/Examples/EulerAuto/src/make.code.defn
+++ b/Examples/EulerAuto/src/make.code.defn
@@ -1,3 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc eulerauto_initial_shock.cc eulerauto_cons_calc_zero_rhs.cc eulerauto_cons_calc_conserved.cc eulerauto_cons_calc_primitives.cc eulerauto_cons_calc_reconstruct_1.cc eulerauto_cons_calc_intercell_conserved_1.cc eulerauto_cons_calc_flux_1.cc eulerauto_cons_calc_rhs_1.cc eulerauto_cons_calc_reconstruct_2.cc eulerauto_cons_calc_intercell_conserved_2.cc eulerauto_cons_calc_flux_2.cc eulerauto_cons_calc_rhs_2.cc eulerauto_cons_calc_reconstruct_3.cc eulerauto_cons_calc_intercell_conserved_3.cc eulerauto_cons_calc_flux_3.cc eulerauto_cons_calc_rhs_3.cc Boundaries.cc 
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc eulerauto_initial_shock.cc eulerauto_cons_calc_zero_rhs.cc eulerauto_cons_calc_conserved.cc eulerauto_cons_calc_primitives.cc eulerauto_cons_calc_reconstruct_1.cc eulerauto_cons_calc_intercell_conserved_1.cc eulerauto_cons_calc_flux_1.cc eulerauto_cons_calc_rhs_1.cc eulerauto_cons_calc_reconstruct_2.cc eulerauto_cons_calc_intercell_conserved_2.cc eulerauto_cons_calc_flux_2.cc eulerauto_cons_calc_rhs_2.cc eulerauto_cons_calc_reconstruct_3.cc eulerauto_cons_calc_intercell_conserved_3.cc eulerauto_cons_calc_flux_3.cc eulerauto_cons_calc_rhs_3.cc Boundaries.cc 
diff --git a/Examples/EulerSR/schedule.ccl b/Examples/EulerSR/schedule.ccl
index d6b29e0..87edede 100644
--- a/Examples/EulerSR/schedule.ccl
+++ b/Examples/EulerSR/schedule.ccl
@@ -190,12 +190,6 @@ schedule EulerSR_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule EulerSR_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule EulerSR_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
@@ -208,22 +202,68 @@ if (CCTK_EQUALS(initial_data, "shock"))
   schedule eulersr_initial_shock at CCTK_INITIAL as eulersr_initial
   {
     LANG: C
+    READS:    grid::x
+    WRITES:   EulerSR::epsi
+    WRITES:   EulerSR::rho
+    WRITES:   EulerSR::v1
+    WRITES:   EulerSR::v2
+    WRITES:   EulerSR::v3
   } "eulersr_initial_shock"
 }
 
 schedule eulersr_cons_calc_zero_rhs in MoL_CalcRHS
 {
   LANG: C
+  WRITES:   EulerSR::Denrhs
+  WRITES:   EulerSR::S1rhs
+  WRITES:   EulerSR::S2rhs
+  WRITES:   EulerSR::S3rhs
+  WRITES:   EulerSR::taurhs
 } "eulersr_cons_calc_zero_rhs"
 
 schedule eulersr_cons_calc_conserved at POSTINITIAL
 {
   LANG: C
+  READS:    EulerSR::Den
+  READS:    EulerSR::epsi
+  READS:    EulerSR::h
+  READS:    EulerSR::p
+  READS:    EulerSR::rho
+  READS:    EulerSR::v1
+  READS:    EulerSR::v2
+  READS:    EulerSR::v3
+  READS:    EulerSR::W
+  WRITES:   EulerSR::Den
+  WRITES:   EulerSR::h
+  WRITES:   EulerSR::p
+  WRITES:   EulerSR::S1
+  WRITES:   EulerSR::S2
+  WRITES:   EulerSR::S3
+  WRITES:   EulerSR::tau
+  WRITES:   EulerSR::W
 } "eulersr_cons_calc_conserved"
 
 schedule eulersr_cons_calc_primitives in MoL_PostStep after EulerSR_ApplyBCs
 {
   LANG: C
+  READS:    EulerSR::Den
+  READS:    EulerSR::epsi
+  READS:    EulerSR::h
+  READS:    EulerSR::p
+  READS:    EulerSR::rho
+  READS:    EulerSR::S1
+  READS:    EulerSR::S2
+  READS:    EulerSR::S3
+  READS:    EulerSR::tau
+  READS:    EulerSR::W
+  WRITES:   EulerSR::epsi
+  WRITES:   EulerSR::h
+  WRITES:   EulerSR::p
+  WRITES:   EulerSR::rho
+  WRITES:   EulerSR::v1
+  WRITES:   EulerSR::v2
+  WRITES:   EulerSR::v3
+  WRITES:   EulerSR::W
 } "eulersr_cons_calc_primitives"
 
 schedule group eulersr_cons_calc_reconstruct_1_group in MoL_CalcRHS after eulersr_cons_calc_zero_rhs
@@ -234,6 +274,21 @@ schedule group eulersr_cons_calc_reconstruct_1_group in MoL_CalcRHS after eulers
 schedule eulersr_cons_calc_reconstruct_1 in eulersr_cons_calc_reconstruct_1_group
 {
   LANG: C
+  READS:    EulerSR::epsi
+  READS:    EulerSR::rho
+  READS:    EulerSR::v1
+  READS:    EulerSR::v2
+  READS:    EulerSR::v3
+  WRITES:   EulerSR::epsiLeft
+  WRITES:   EulerSR::epsiRight
+  WRITES:   EulerSR::rhoLeft
+  WRITES:   EulerSR::rhoRight
+  WRITES:   EulerSR::v1Left
+  WRITES:   EulerSR::v1Right
+  WRITES:   EulerSR::v2Left
+  WRITES:   EulerSR::v2Right
+  WRITES:   EulerSR::v3Left
+  WRITES:   EulerSR::v3Right
 } "eulersr_cons_calc_reconstruct_1"
 
 schedule eulersr_cons_calc_reconstruct_1_SelectBCs in eulersr_cons_calc_reconstruct_1_bc_group
@@ -265,6 +320,34 @@ schedule group eulersr_cons_calc_reconstruct_1_bc_group in MoL_PseudoEvolutionBo
 schedule eulersr_cons_calc_intercell_conserved_1 in MoL_CalcRHS after eulersr_cons_calc_reconstruct_1
 {
   LANG: C
+  READS:    EulerSR::DenLeft
+  READS:    EulerSR::DenRight
+  READS:    EulerSR::epsiLeft
+  READS:    EulerSR::epsiRight
+  READS:    EulerSR::h
+  READS:    EulerSR::p
+  READS:    EulerSR::rhoLeft
+  READS:    EulerSR::rhoRight
+  READS:    EulerSR::v1Left
+  READS:    EulerSR::v1Right
+  READS:    EulerSR::v2Left
+  READS:    EulerSR::v2Right
+  READS:    EulerSR::v3Left
+  READS:    EulerSR::v3Right
+  READS:    EulerSR::W
+  WRITES:   EulerSR::DenLeft
+  WRITES:   EulerSR::DenRight
+  WRITES:   EulerSR::h
+  WRITES:   EulerSR::p
+  WRITES:   EulerSR::S1Left
+  WRITES:   EulerSR::S1Right
+  WRITES:   EulerSR::S2Left
+  WRITES:   EulerSR::S2Right
+  WRITES:   EulerSR::S3Left
+  WRITES:   EulerSR::S3Right
+  WRITES:   EulerSR::tauLeft
+  WRITES:   EulerSR::tauRight
+  WRITES:   EulerSR::W
 } "eulersr_cons_calc_intercell_conserved_1"
 
 schedule group eulersr_cons_calc_flux_1_group in MoL_CalcRHS after eulersr_cons_calc_intercell_conserved_1
@@ -275,6 +358,27 @@ schedule group eulersr_cons_calc_flux_1_group in MoL_CalcRHS after eulersr_cons_
 schedule eulersr_cons_calc_flux_1 in eulersr_cons_calc_flux_1_group
 {
   LANG: C
+  READS:    EulerSR::DenLeft
+  READS:    EulerSR::DenRight
+  READS:    EulerSR::epsiLeft
+  READS:    EulerSR::epsiRight
+  READS:    EulerSR::rhoLeft
+  READS:    EulerSR::rhoRight
+  READS:    EulerSR::S1Left
+  READS:    EulerSR::S1Right
+  READS:    EulerSR::S2Left
+  READS:    EulerSR::S2Right
+  READS:    EulerSR::S3Left
+  READS:    EulerSR::S3Right
+  READS:    EulerSR::tauLeft
+  READS:    EulerSR::tauRight
+  READS:    EulerSR::v1Left
+  READS:    EulerSR::v1Right
+  WRITES:   EulerSR::DenFlux
+  WRITES:   EulerSR::S1Flux
+  WRITES:   EulerSR::S2Flux
+  WRITES:   EulerSR::S3Flux
+  WRITES:   EulerSR::tauFlux
 } "eulersr_cons_calc_flux_1"
 
 schedule eulersr_cons_calc_flux_1_SelectBCs in eulersr_cons_calc_flux_1_bc_group
@@ -306,6 +410,21 @@ schedule group eulersr_cons_calc_flux_1_bc_group in MoL_PseudoEvolutionBoundarie
 schedule eulersr_cons_calc_rhs_1 in MoL_CalcRHS after eulersr_cons_calc_flux_1
 {
   LANG: C
+  READS:    EulerSR::DenFlux
+  READS:    EulerSR::Denrhs
+  READS:    EulerSR::S1Flux
+  READS:    EulerSR::S1rhs
+  READS:    EulerSR::S2Flux
+  READS:    EulerSR::S2rhs
+  READS:    EulerSR::S3Flux
+  READS:    EulerSR::S3rhs
+  READS:    EulerSR::tauFlux
+  READS:    EulerSR::taurhs
+  WRITES:   EulerSR::Denrhs
+  WRITES:   EulerSR::S1rhs
+  WRITES:   EulerSR::S2rhs
+  WRITES:   EulerSR::S3rhs
+  WRITES:   EulerSR::taurhs
 } "eulersr_cons_calc_rhs_1"
 
 schedule group eulersr_cons_calc_reconstruct_2_group in MoL_CalcRHS after eulersr_cons_calc_rhs_1
@@ -316,6 +435,21 @@ schedule group eulersr_cons_calc_reconstruct_2_group in MoL_CalcRHS after eulers
 schedule eulersr_cons_calc_reconstruct_2 in eulersr_cons_calc_reconstruct_2_group
 {
   LANG: C
+  READS:    EulerSR::epsi
+  READS:    EulerSR::rho
+  READS:    EulerSR::v1
+  READS:    EulerSR::v2
+  READS:    EulerSR::v3
+  WRITES:   EulerSR::epsiLeft
+  WRITES:   EulerSR::epsiRight
+  WRITES:   EulerSR::rhoLeft
+  WRITES:   EulerSR::rhoRight
+  WRITES:   EulerSR::v1Left
+  WRITES:   EulerSR::v1Right
+  WRITES:   EulerSR::v2Left
+  WRITES:   EulerSR::v2Right
+  WRITES:   EulerSR::v3Left
+  WRITES:   EulerSR::v3Right
 } "eulersr_cons_calc_reconstruct_2"
 
 schedule eulersr_cons_calc_reconstruct_2_SelectBCs in eulersr_cons_calc_reconstruct_2_bc_group
@@ -347,6 +481,34 @@ schedule group eulersr_cons_calc_reconstruct_2_bc_group in MoL_PseudoEvolutionBo
 schedule eulersr_cons_calc_intercell_conserved_2 in MoL_CalcRHS after eulersr_cons_calc_reconstruct_2
 {
   LANG: C
+  READS:    EulerSR::DenLeft
+  READS:    EulerSR::DenRight
+  READS:    EulerSR::epsiLeft
+  READS:    EulerSR::epsiRight
+  READS:    EulerSR::h
+  READS:    EulerSR::p
+  READS:    EulerSR::rhoLeft
+  READS:    EulerSR::rhoRight
+  READS:    EulerSR::v1Left
+  READS:    EulerSR::v1Right
+  READS:    EulerSR::v2Left
+  READS:    EulerSR::v2Right
+  READS:    EulerSR::v3Left
+  READS:    EulerSR::v3Right
+  READS:    EulerSR::W
+  WRITES:   EulerSR::DenLeft
+  WRITES:   EulerSR::DenRight
+  WRITES:   EulerSR::h
+  WRITES:   EulerSR::p
+  WRITES:   EulerSR::S1Left
+  WRITES:   EulerSR::S1Right
+  WRITES:   EulerSR::S2Left
+  WRITES:   EulerSR::S2Right
+  WRITES:   EulerSR::S3Left
+  WRITES:   EulerSR::S3Right
+  WRITES:   EulerSR::tauLeft
+  WRITES:   EulerSR::tauRight
+  WRITES:   EulerSR::W
 } "eulersr_cons_calc_intercell_conserved_2"
 
 schedule group eulersr_cons_calc_flux_2_group in MoL_CalcRHS after eulersr_cons_calc_intercell_conserved_2
@@ -357,6 +519,27 @@ schedule group eulersr_cons_calc_flux_2_group in MoL_CalcRHS after eulersr_cons_
 schedule eulersr_cons_calc_flux_2 in eulersr_cons_calc_flux_2_group
 {
   LANG: C
+  READS:    EulerSR::DenLeft
+  READS:    EulerSR::DenRight
+  READS:    EulerSR::epsiLeft
+  READS:    EulerSR::epsiRight
+  READS:    EulerSR::rhoLeft
+  READS:    EulerSR::rhoRight
+  READS:    EulerSR::S1Left
+  READS:    EulerSR::S1Right
+  READS:    EulerSR::S2Left
+  READS:    EulerSR::S2Right
+  READS:    EulerSR::S3Left
+  READS:    EulerSR::S3Right
+  READS:    EulerSR::tauLeft
+  READS:    EulerSR::tauRight
+  READS:    EulerSR::v2Left
+  READS:    EulerSR::v2Right
+  WRITES:   EulerSR::DenFlux
+  WRITES:   EulerSR::S1Flux
+  WRITES:   EulerSR::S2Flux
+  WRITES:   EulerSR::S3Flux
+  WRITES:   EulerSR::tauFlux
 } "eulersr_cons_calc_flux_2"
 
 schedule eulersr_cons_calc_flux_2_SelectBCs in eulersr_cons_calc_flux_2_bc_group
@@ -388,6 +571,21 @@ schedule group eulersr_cons_calc_flux_2_bc_group in MoL_PseudoEvolutionBoundarie
 schedule eulersr_cons_calc_rhs_2 in MoL_CalcRHS after eulersr_cons_calc_flux_2
 {
   LANG: C
+  READS:    EulerSR::DenFlux
+  READS:    EulerSR::Denrhs
+  READS:    EulerSR::S1Flux
+  READS:    EulerSR::S1rhs
+  READS:    EulerSR::S2Flux
+  READS:    EulerSR::S2rhs
+  READS:    EulerSR::S3Flux
+  READS:    EulerSR::S3rhs
+  READS:    EulerSR::tauFlux
+  READS:    EulerSR::taurhs
+  WRITES:   EulerSR::Denrhs
+  WRITES:   EulerSR::S1rhs
+  WRITES:   EulerSR::S2rhs
+  WRITES:   EulerSR::S3rhs
+  WRITES:   EulerSR::taurhs
 } "eulersr_cons_calc_rhs_2"
 
 schedule group eulersr_cons_calc_reconstruct_3_group in MoL_CalcRHS after eulersr_cons_calc_rhs_2
@@ -398,6 +596,21 @@ schedule group eulersr_cons_calc_reconstruct_3_group in MoL_CalcRHS after eulers
 schedule eulersr_cons_calc_reconstruct_3 in eulersr_cons_calc_reconstruct_3_group
 {
   LANG: C
+  READS:    EulerSR::epsi
+  READS:    EulerSR::rho
+  READS:    EulerSR::v1
+  READS:    EulerSR::v2
+  READS:    EulerSR::v3
+  WRITES:   EulerSR::epsiLeft
+  WRITES:   EulerSR::epsiRight
+  WRITES:   EulerSR::rhoLeft
+  WRITES:   EulerSR::rhoRight
+  WRITES:   EulerSR::v1Left
+  WRITES:   EulerSR::v1Right
+  WRITES:   EulerSR::v2Left
+  WRITES:   EulerSR::v2Right
+  WRITES:   EulerSR::v3Left
+  WRITES:   EulerSR::v3Right
 } "eulersr_cons_calc_reconstruct_3"
 
 schedule eulersr_cons_calc_reconstruct_3_SelectBCs in eulersr_cons_calc_reconstruct_3_bc_group
@@ -429,6 +642,34 @@ schedule group eulersr_cons_calc_reconstruct_3_bc_group in MoL_PseudoEvolutionBo
 schedule eulersr_cons_calc_intercell_conserved_3 in MoL_CalcRHS after eulersr_cons_calc_reconstruct_3
 {
   LANG: C
+  READS:    EulerSR::DenLeft
+  READS:    EulerSR::DenRight
+  READS:    EulerSR::epsiLeft
+  READS:    EulerSR::epsiRight
+  READS:    EulerSR::h
+  READS:    EulerSR::p
+  READS:    EulerSR::rhoLeft
+  READS:    EulerSR::rhoRight
+  READS:    EulerSR::v1Left
+  READS:    EulerSR::v1Right
+  READS:    EulerSR::v2Left
+  READS:    EulerSR::v2Right
+  READS:    EulerSR::v3Left
+  READS:    EulerSR::v3Right
+  READS:    EulerSR::W
+  WRITES:   EulerSR::DenLeft
+  WRITES:   EulerSR::DenRight
+  WRITES:   EulerSR::h
+  WRITES:   EulerSR::p
+  WRITES:   EulerSR::S1Left
+  WRITES:   EulerSR::S1Right
+  WRITES:   EulerSR::S2Left
+  WRITES:   EulerSR::S2Right
+  WRITES:   EulerSR::S3Left
+  WRITES:   EulerSR::S3Right
+  WRITES:   EulerSR::tauLeft
+  WRITES:   EulerSR::tauRight
+  WRITES:   EulerSR::W
 } "eulersr_cons_calc_intercell_conserved_3"
 
 schedule group eulersr_cons_calc_flux_3_group in MoL_CalcRHS after eulersr_cons_calc_intercell_conserved_3
@@ -439,6 +680,27 @@ schedule group eulersr_cons_calc_flux_3_group in MoL_CalcRHS after eulersr_cons_
 schedule eulersr_cons_calc_flux_3 in eulersr_cons_calc_flux_3_group
 {
   LANG: C
+  READS:    EulerSR::DenLeft
+  READS:    EulerSR::DenRight
+  READS:    EulerSR::epsiLeft
+  READS:    EulerSR::epsiRight
+  READS:    EulerSR::rhoLeft
+  READS:    EulerSR::rhoRight
+  READS:    EulerSR::S1Left
+  READS:    EulerSR::S1Right
+  READS:    EulerSR::S2Left
+  READS:    EulerSR::S2Right
+  READS:    EulerSR::S3Left
+  READS:    EulerSR::S3Right
+  READS:    EulerSR::tauLeft
+  READS:    EulerSR::tauRight
+  READS:    EulerSR::v3Left
+  READS:    EulerSR::v3Right
+  WRITES:   EulerSR::DenFlux
+  WRITES:   EulerSR::S1Flux
+  WRITES:   EulerSR::S2Flux
+  WRITES:   EulerSR::S3Flux
+  WRITES:   EulerSR::tauFlux
 } "eulersr_cons_calc_flux_3"
 
 schedule eulersr_cons_calc_flux_3_SelectBCs in eulersr_cons_calc_flux_3_bc_group
@@ -470,6 +732,21 @@ schedule group eulersr_cons_calc_flux_3_bc_group in MoL_PseudoEvolutionBoundarie
 schedule eulersr_cons_calc_rhs_3 in MoL_CalcRHS after eulersr_cons_calc_flux_3
 {
   LANG: C
+  READS:    EulerSR::DenFlux
+  READS:    EulerSR::Denrhs
+  READS:    EulerSR::S1Flux
+  READS:    EulerSR::S1rhs
+  READS:    EulerSR::S2Flux
+  READS:    EulerSR::S2rhs
+  READS:    EulerSR::S3Flux
+  READS:    EulerSR::S3rhs
+  READS:    EulerSR::tauFlux
+  READS:    EulerSR::taurhs
+  WRITES:   EulerSR::Denrhs
+  WRITES:   EulerSR::S1rhs
+  WRITES:   EulerSR::S2rhs
+  WRITES:   EulerSR::S3rhs
+  WRITES:   EulerSR::taurhs
 } "eulersr_cons_calc_rhs_3"
 
 schedule EulerSR_SelectBoundConds in MoL_PostStep
@@ -487,6 +764,12 @@ schedule EulerSR_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
+schedule EulerSR_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
 schedule group ApplyBCs as EulerSR_ApplyBCs in MoL_PostStep after EulerSR_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_conserved.cc b/Examples/EulerSR/src/eulersr_cons_calc_conserved.cc
index 673ff99..ba11a6e 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_conserved.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_conserved.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulersr_cons_calc_conserved_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulersr_cons_calc_conserved_Body(cGH const * restrict const cctkGH,
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulersr_cons_calc_conserved_Body(cGH const * restrict const cctkGH,
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_conserved,
+  CCTK_LOOP3(eulersr_cons_calc_conserved,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -124,7 +122,7 @@ static void eulersr_cons_calc_conserved_Body(cGH const * restrict const cctkGH,
     tau[index] = tauL;
     W[index] = WL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_conserved);
+  CCTK_ENDLOOP3(eulersr_cons_calc_conserved);
 }
 
 extern "C" void eulersr_cons_calc_conserved(CCTK_ARGUMENTS)
@@ -143,11 +141,20 @@ extern "C" void eulersr_cons_calc_conserved(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_group","EulerSR::epsi_group","EulerSR::h_group","EulerSR::p_group","EulerSR::rho_group","EulerSR::S_group","EulerSR::tau_group","EulerSR::v_group","EulerSR::W_group"};
+  const char *const groups[] = {
+    "EulerSR::Den_group",
+    "EulerSR::epsi_group",
+    "EulerSR::h_group",
+    "EulerSR::p_group",
+    "EulerSR::rho_group",
+    "EulerSR::S_group",
+    "EulerSR::tau_group",
+    "EulerSR::v_group",
+    "EulerSR::W_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_conserved", 9, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulersr_cons_calc_conserved_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulersr_cons_calc_conserved_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_flux_1.cc b/Examples/EulerSR/src/eulersr_cons_calc_flux_1.cc
index 843de50..a618b63 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_flux_1.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_flux_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulersr_cons_calc_flux_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulersr_cons_calc_flux_1_Body(cGH const * restrict const cctkGH, int
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulersr_cons_calc_flux_1_Body(cGH const * restrict const cctkGH, int
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_flux_1,
+  CCTK_LOOP3(eulersr_cons_calc_flux_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -181,7 +179,7 @@ static void eulersr_cons_calc_flux_1_Body(cGH const * restrict const cctkGH, int
     S3Flux[index] = S3FluxL;
     tauFlux[index] = tauFluxL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_flux_1);
+  CCTK_ENDLOOP3(eulersr_cons_calc_flux_1);
 }
 
 extern "C" void eulersr_cons_calc_flux_1(CCTK_ARGUMENTS)
@@ -200,12 +198,25 @@ extern "C" void eulersr_cons_calc_flux_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_flux_group","EulerSR::Den_lr_group","EulerSR::epsi_lr_group","EulerSR::rho_lr_group","EulerSR::S1_flux_group","EulerSR::S1_lr_group","EulerSR::S2_flux_group","EulerSR::S2_lr_group","EulerSR::S3_flux_group","EulerSR::S3_lr_group","EulerSR::tau_flux_group","EulerSR::tau_lr_group","EulerSR::v1_lr_group"};
+  const char *const groups[] = {
+    "EulerSR::Den_flux_group",
+    "EulerSR::Den_lr_group",
+    "EulerSR::epsi_lr_group",
+    "EulerSR::rho_lr_group",
+    "EulerSR::S1_flux_group",
+    "EulerSR::S1_lr_group",
+    "EulerSR::S2_flux_group",
+    "EulerSR::S2_lr_group",
+    "EulerSR::S3_flux_group",
+    "EulerSR::S3_lr_group",
+    "EulerSR::tau_flux_group",
+    "EulerSR::tau_lr_group",
+    "EulerSR::v1_lr_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_flux_1", 13, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulersr_cons_calc_flux_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulersr_cons_calc_flux_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulersr_cons_calc_flux_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_flux_2.cc b/Examples/EulerSR/src/eulersr_cons_calc_flux_2.cc
index fb8553c..9c264a5 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_flux_2.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_flux_2.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulersr_cons_calc_flux_2_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulersr_cons_calc_flux_2_Body(cGH const * restrict const cctkGH, int
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulersr_cons_calc_flux_2_Body(cGH const * restrict const cctkGH, int
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_flux_2,
+  CCTK_LOOP3(eulersr_cons_calc_flux_2,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -181,7 +179,7 @@ static void eulersr_cons_calc_flux_2_Body(cGH const * restrict const cctkGH, int
     S3Flux[index] = S3FluxL;
     tauFlux[index] = tauFluxL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_flux_2);
+  CCTK_ENDLOOP3(eulersr_cons_calc_flux_2);
 }
 
 extern "C" void eulersr_cons_calc_flux_2(CCTK_ARGUMENTS)
@@ -200,12 +198,25 @@ extern "C" void eulersr_cons_calc_flux_2(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_flux_group","EulerSR::Den_lr_group","EulerSR::epsi_lr_group","EulerSR::rho_lr_group","EulerSR::S1_flux_group","EulerSR::S1_lr_group","EulerSR::S2_flux_group","EulerSR::S2_lr_group","EulerSR::S3_flux_group","EulerSR::S3_lr_group","EulerSR::tau_flux_group","EulerSR::tau_lr_group","EulerSR::v2_lr_group"};
+  const char *const groups[] = {
+    "EulerSR::Den_flux_group",
+    "EulerSR::Den_lr_group",
+    "EulerSR::epsi_lr_group",
+    "EulerSR::rho_lr_group",
+    "EulerSR::S1_flux_group",
+    "EulerSR::S1_lr_group",
+    "EulerSR::S2_flux_group",
+    "EulerSR::S2_lr_group",
+    "EulerSR::S3_flux_group",
+    "EulerSR::S3_lr_group",
+    "EulerSR::tau_flux_group",
+    "EulerSR::tau_lr_group",
+    "EulerSR::v2_lr_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_flux_2", 13, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulersr_cons_calc_flux_2", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulersr_cons_calc_flux_2_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulersr_cons_calc_flux_2_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_flux_3.cc b/Examples/EulerSR/src/eulersr_cons_calc_flux_3.cc
index 90fc2b7..ede78c8 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_flux_3.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_flux_3.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulersr_cons_calc_flux_3_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulersr_cons_calc_flux_3_Body(cGH const * restrict const cctkGH, int
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulersr_cons_calc_flux_3_Body(cGH const * restrict const cctkGH, int
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_flux_3,
+  CCTK_LOOP3(eulersr_cons_calc_flux_3,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -181,7 +179,7 @@ static void eulersr_cons_calc_flux_3_Body(cGH const * restrict const cctkGH, int
     S3Flux[index] = S3FluxL;
     tauFlux[index] = tauFluxL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_flux_3);
+  CCTK_ENDLOOP3(eulersr_cons_calc_flux_3);
 }
 
 extern "C" void eulersr_cons_calc_flux_3(CCTK_ARGUMENTS)
@@ -200,12 +198,25 @@ extern "C" void eulersr_cons_calc_flux_3(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_flux_group","EulerSR::Den_lr_group","EulerSR::epsi_lr_group","EulerSR::rho_lr_group","EulerSR::S1_flux_group","EulerSR::S1_lr_group","EulerSR::S2_flux_group","EulerSR::S2_lr_group","EulerSR::S3_flux_group","EulerSR::S3_lr_group","EulerSR::tau_flux_group","EulerSR::tau_lr_group","EulerSR::v3_lr_group"};
+  const char *const groups[] = {
+    "EulerSR::Den_flux_group",
+    "EulerSR::Den_lr_group",
+    "EulerSR::epsi_lr_group",
+    "EulerSR::rho_lr_group",
+    "EulerSR::S1_flux_group",
+    "EulerSR::S1_lr_group",
+    "EulerSR::S2_flux_group",
+    "EulerSR::S2_lr_group",
+    "EulerSR::S3_flux_group",
+    "EulerSR::S3_lr_group",
+    "EulerSR::tau_flux_group",
+    "EulerSR::tau_lr_group",
+    "EulerSR::v3_lr_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_flux_3", 13, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulersr_cons_calc_flux_3", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulersr_cons_calc_flux_3_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulersr_cons_calc_flux_3_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_1.cc b/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_1.cc
index df163c1..773d8f5 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_1.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulersr_cons_calc_intercell_conserved_1_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulersr_cons_calc_intercell_conserved_1_Body(cGH const * restrict co
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulersr_cons_calc_intercell_conserved_1_Body(cGH const * restrict co
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_intercell_conserved_1,
+  CCTK_LOOP3(eulersr_cons_calc_intercell_conserved_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -154,7 +152,7 @@ static void eulersr_cons_calc_intercell_conserved_1_Body(cGH const * restrict co
     tauRight[index] = tauRightL;
     W[index] = WL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_intercell_conserved_1);
+  CCTK_ENDLOOP3(eulersr_cons_calc_intercell_conserved_1);
 }
 
 extern "C" void eulersr_cons_calc_intercell_conserved_1(CCTK_ARGUMENTS)
@@ -173,11 +171,24 @@ extern "C" void eulersr_cons_calc_intercell_conserved_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_lr_group","EulerSR::epsi_lr_group","EulerSR::h_group","EulerSR::p_group","EulerSR::rho_lr_group","EulerSR::S1_lr_group","EulerSR::S2_lr_group","EulerSR::S3_lr_group","EulerSR::tau_lr_group","EulerSR::v1_lr_group","EulerSR::v2_lr_group","EulerSR::v3_lr_group","EulerSR::W_group"};
+  const char *const groups[] = {
+    "EulerSR::Den_lr_group",
+    "EulerSR::epsi_lr_group",
+    "EulerSR::h_group",
+    "EulerSR::p_group",
+    "EulerSR::rho_lr_group",
+    "EulerSR::S1_lr_group",
+    "EulerSR::S2_lr_group",
+    "EulerSR::S3_lr_group",
+    "EulerSR::tau_lr_group",
+    "EulerSR::v1_lr_group",
+    "EulerSR::v2_lr_group",
+    "EulerSR::v3_lr_group",
+    "EulerSR::W_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_intercell_conserved_1", 13, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulersr_cons_calc_intercell_conserved_1_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulersr_cons_calc_intercell_conserved_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_2.cc b/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_2.cc
index 83616ac..a40fee7 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_2.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_2.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulersr_cons_calc_intercell_conserved_2_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulersr_cons_calc_intercell_conserved_2_Body(cGH const * restrict co
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulersr_cons_calc_intercell_conserved_2_Body(cGH const * restrict co
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_intercell_conserved_2,
+  CCTK_LOOP3(eulersr_cons_calc_intercell_conserved_2,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -154,7 +152,7 @@ static void eulersr_cons_calc_intercell_conserved_2_Body(cGH const * restrict co
     tauRight[index] = tauRightL;
     W[index] = WL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_intercell_conserved_2);
+  CCTK_ENDLOOP3(eulersr_cons_calc_intercell_conserved_2);
 }
 
 extern "C" void eulersr_cons_calc_intercell_conserved_2(CCTK_ARGUMENTS)
@@ -173,11 +171,24 @@ extern "C" void eulersr_cons_calc_intercell_conserved_2(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_lr_group","EulerSR::epsi_lr_group","EulerSR::h_group","EulerSR::p_group","EulerSR::rho_lr_group","EulerSR::S1_lr_group","EulerSR::S2_lr_group","EulerSR::S3_lr_group","EulerSR::tau_lr_group","EulerSR::v1_lr_group","EulerSR::v2_lr_group","EulerSR::v3_lr_group","EulerSR::W_group"};
+  const char *const groups[] = {
+    "EulerSR::Den_lr_group",
+    "EulerSR::epsi_lr_group",
+    "EulerSR::h_group",
+    "EulerSR::p_group",
+    "EulerSR::rho_lr_group",
+    "EulerSR::S1_lr_group",
+    "EulerSR::S2_lr_group",
+    "EulerSR::S3_lr_group",
+    "EulerSR::tau_lr_group",
+    "EulerSR::v1_lr_group",
+    "EulerSR::v2_lr_group",
+    "EulerSR::v3_lr_group",
+    "EulerSR::W_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_intercell_conserved_2", 13, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulersr_cons_calc_intercell_conserved_2_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulersr_cons_calc_intercell_conserved_2_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_3.cc b/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_3.cc
index 4cc9ef2..1ac3fae 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_3.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_intercell_conserved_3.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulersr_cons_calc_intercell_conserved_3_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulersr_cons_calc_intercell_conserved_3_Body(cGH const * restrict co
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulersr_cons_calc_intercell_conserved_3_Body(cGH const * restrict co
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_intercell_conserved_3,
+  CCTK_LOOP3(eulersr_cons_calc_intercell_conserved_3,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -154,7 +152,7 @@ static void eulersr_cons_calc_intercell_conserved_3_Body(cGH const * restrict co
     tauRight[index] = tauRightL;
     W[index] = WL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_intercell_conserved_3);
+  CCTK_ENDLOOP3(eulersr_cons_calc_intercell_conserved_3);
 }
 
 extern "C" void eulersr_cons_calc_intercell_conserved_3(CCTK_ARGUMENTS)
@@ -173,11 +171,24 @@ extern "C" void eulersr_cons_calc_intercell_conserved_3(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_lr_group","EulerSR::epsi_lr_group","EulerSR::h_group","EulerSR::p_group","EulerSR::rho_lr_group","EulerSR::S1_lr_group","EulerSR::S2_lr_group","EulerSR::S3_lr_group","EulerSR::tau_lr_group","EulerSR::v1_lr_group","EulerSR::v2_lr_group","EulerSR::v3_lr_group","EulerSR::W_group"};
+  const char *const groups[] = {
+    "EulerSR::Den_lr_group",
+    "EulerSR::epsi_lr_group",
+    "EulerSR::h_group",
+    "EulerSR::p_group",
+    "EulerSR::rho_lr_group",
+    "EulerSR::S1_lr_group",
+    "EulerSR::S2_lr_group",
+    "EulerSR::S3_lr_group",
+    "EulerSR::tau_lr_group",
+    "EulerSR::v1_lr_group",
+    "EulerSR::v2_lr_group",
+    "EulerSR::v3_lr_group",
+    "EulerSR::W_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_intercell_conserved_3", 13, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulersr_cons_calc_intercell_conserved_3_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulersr_cons_calc_intercell_conserved_3_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_primitives.cc b/Examples/EulerSR/src/eulersr_cons_calc_primitives.cc
index b43f41a..8f58a2a 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_primitives.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_primitives.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulersr_cons_calc_primitives_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulersr_cons_calc_primitives_Body(cGH const * restrict const cctkGH,
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulersr_cons_calc_primitives_Body(cGH const * restrict const cctkGH,
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_primitives,
+  CCTK_LOOP3(eulersr_cons_calc_primitives,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -111,7 +109,7 @@ static void eulersr_cons_calc_primitives_Body(cGH const * restrict const cctkGH,
     
     rhoL = DenL*INV(WL);
     
-    hL = Z*INV(rhoL)*INV(SQR(WL));
+    hL = Z*INV(rhoL*SQR(WL));
     
     epsiL = hL - (rhoL + pBar)*INV(rhoL);
     
@@ -136,7 +134,7 @@ static void eulersr_cons_calc_primitives_Body(cGH const * restrict const cctkGH,
     
     rhoL = DenL*INV(WL);
     
-    hL = Z*INV(rhoL)*INV(SQR(WL));
+    hL = Z*INV(rhoL*SQR(WL));
     
     epsiL = hL - (rhoL + pBar)*INV(rhoL);
     
@@ -160,7 +158,7 @@ static void eulersr_cons_calc_primitives_Body(cGH const * restrict const cctkGH,
     
     rhoL = DenL*INV(WL);
     
-    hL = Z*INV(rhoL)*INV(SQR(WL));
+    hL = Z*INV(rhoL*SQR(WL));
     
     epsiL = hL - (rhoL + pBar)*INV(rhoL);
     
@@ -184,7 +182,7 @@ static void eulersr_cons_calc_primitives_Body(cGH const * restrict const cctkGH,
     
     rhoL = DenL*INV(WL);
     
-    hL = Z*INV(rhoL)*INV(SQR(WL));
+    hL = Z*INV(rhoL*SQR(WL));
     
     epsiL = hL - (rhoL + pBar)*INV(rhoL);
     
@@ -208,7 +206,7 @@ static void eulersr_cons_calc_primitives_Body(cGH const * restrict const cctkGH,
     
     rhoL = DenL*INV(WL);
     
-    hL = Z*INV(rhoL)*INV(SQR(WL));
+    hL = Z*INV(rhoL*SQR(WL));
     
     epsiL = hL - (rhoL + pBar)*INV(rhoL);
     
@@ -224,11 +222,11 @@ static void eulersr_cons_calc_primitives_Body(cGH const * restrict const cctkGH,
     
     pL = pBar;
     
-    CCTK_REAL v1L = S1L*INV(hL)*INV(rhoL)*INV(SQR(WL));
+    CCTK_REAL v1L = S1L*INV(hL*rhoL*SQR(WL));
     
-    CCTK_REAL v2L = S2L*INV(hL)*INV(rhoL)*INV(SQR(WL));
+    CCTK_REAL v2L = S2L*INV(hL*rhoL*SQR(WL));
     
-    CCTK_REAL v3L = S3L*INV(hL)*INV(rhoL)*INV(SQR(WL));
+    CCTK_REAL v3L = S3L*INV(hL*rhoL*SQR(WL));
     
     /* Copy local copies back to grid functions */
     epsi[index] = epsiL;
@@ -240,7 +238,7 @@ static void eulersr_cons_calc_primitives_Body(cGH const * restrict const cctkGH,
     v3[index] = v3L;
     W[index] = WL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_primitives);
+  CCTK_ENDLOOP3(eulersr_cons_calc_primitives);
 }
 
 extern "C" void eulersr_cons_calc_primitives(CCTK_ARGUMENTS)
@@ -259,11 +257,20 @@ extern "C" void eulersr_cons_calc_primitives(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_group","EulerSR::epsi_group","EulerSR::h_group","EulerSR::p_group","EulerSR::rho_group","EulerSR::S_group","EulerSR::tau_group","EulerSR::v_group","EulerSR::W_group"};
+  const char *const groups[] = {
+    "EulerSR::Den_group",
+    "EulerSR::epsi_group",
+    "EulerSR::h_group",
+    "EulerSR::p_group",
+    "EulerSR::rho_group",
+    "EulerSR::S_group",
+    "EulerSR::tau_group",
+    "EulerSR::v_group",
+    "EulerSR::W_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_primitives", 9, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulersr_cons_calc_primitives_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulersr_cons_calc_primitives_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_1.cc b/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_1.cc
index 347fb53..98c55bb 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_1.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulersr_cons_calc_reconstruct_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulersr_cons_calc_reconstruct_1_Body(cGH const * restrict const cctk
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulersr_cons_calc_reconstruct_1_Body(cGH const * restrict const cctk
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_reconstruct_1,
+  CCTK_LOOP3(eulersr_cons_calc_reconstruct_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -188,7 +186,7 @@ static void eulersr_cons_calc_reconstruct_1_Body(cGH const * restrict const cctk
     v3Left[index] = v3LeftL;
     v3Right[index] = v3RightL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_reconstruct_1);
+  CCTK_ENDLOOP3(eulersr_cons_calc_reconstruct_1);
 }
 
 extern "C" void eulersr_cons_calc_reconstruct_1(CCTK_ARGUMENTS)
@@ -207,12 +205,20 @@ extern "C" void eulersr_cons_calc_reconstruct_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::epsi_group","EulerSR::epsi_lr_group","EulerSR::rho_group","EulerSR::rho_lr_group","EulerSR::v1_lr_group","EulerSR::v2_lr_group","EulerSR::v3_lr_group","EulerSR::v_group"};
+  const char *const groups[] = {
+    "EulerSR::epsi_group",
+    "EulerSR::epsi_lr_group",
+    "EulerSR::rho_group",
+    "EulerSR::rho_lr_group",
+    "EulerSR::v1_lr_group",
+    "EulerSR::v2_lr_group",
+    "EulerSR::v3_lr_group",
+    "EulerSR::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_reconstruct_1", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulersr_cons_calc_reconstruct_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulersr_cons_calc_reconstruct_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulersr_cons_calc_reconstruct_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_2.cc b/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_2.cc
index 420741b..a0b8409 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_2.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_2.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulersr_cons_calc_reconstruct_2_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulersr_cons_calc_reconstruct_2_Body(cGH const * restrict const cctk
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulersr_cons_calc_reconstruct_2_Body(cGH const * restrict const cctk
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_reconstruct_2,
+  CCTK_LOOP3(eulersr_cons_calc_reconstruct_2,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -188,7 +186,7 @@ static void eulersr_cons_calc_reconstruct_2_Body(cGH const * restrict const cctk
     v3Left[index] = v3LeftL;
     v3Right[index] = v3RightL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_reconstruct_2);
+  CCTK_ENDLOOP3(eulersr_cons_calc_reconstruct_2);
 }
 
 extern "C" void eulersr_cons_calc_reconstruct_2(CCTK_ARGUMENTS)
@@ -207,12 +205,20 @@ extern "C" void eulersr_cons_calc_reconstruct_2(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::epsi_group","EulerSR::epsi_lr_group","EulerSR::rho_group","EulerSR::rho_lr_group","EulerSR::v1_lr_group","EulerSR::v2_lr_group","EulerSR::v3_lr_group","EulerSR::v_group"};
+  const char *const groups[] = {
+    "EulerSR::epsi_group",
+    "EulerSR::epsi_lr_group",
+    "EulerSR::rho_group",
+    "EulerSR::rho_lr_group",
+    "EulerSR::v1_lr_group",
+    "EulerSR::v2_lr_group",
+    "EulerSR::v3_lr_group",
+    "EulerSR::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_reconstruct_2", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulersr_cons_calc_reconstruct_2", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulersr_cons_calc_reconstruct_2_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulersr_cons_calc_reconstruct_2_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_3.cc b/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_3.cc
index d0d6b42..6536df9 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_3.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_reconstruct_3.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulersr_cons_calc_reconstruct_3_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -52,8 +52,6 @@ static void eulersr_cons_calc_reconstruct_3_Body(cGH const * restrict const cctk
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -96,9 +94,9 @@ static void eulersr_cons_calc_reconstruct_3_Body(cGH const * restrict const cctk
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_reconstruct_3,
+  CCTK_LOOP3(eulersr_cons_calc_reconstruct_3,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -188,7 +186,7 @@ static void eulersr_cons_calc_reconstruct_3_Body(cGH const * restrict const cctk
     v3Left[index] = v3LeftL;
     v3Right[index] = v3RightL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_reconstruct_3);
+  CCTK_ENDLOOP3(eulersr_cons_calc_reconstruct_3);
 }
 
 extern "C" void eulersr_cons_calc_reconstruct_3(CCTK_ARGUMENTS)
@@ -207,12 +205,20 @@ extern "C" void eulersr_cons_calc_reconstruct_3(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::epsi_group","EulerSR::epsi_lr_group","EulerSR::rho_group","EulerSR::rho_lr_group","EulerSR::v1_lr_group","EulerSR::v2_lr_group","EulerSR::v3_lr_group","EulerSR::v_group"};
+  const char *const groups[] = {
+    "EulerSR::epsi_group",
+    "EulerSR::epsi_lr_group",
+    "EulerSR::rho_group",
+    "EulerSR::rho_lr_group",
+    "EulerSR::v1_lr_group",
+    "EulerSR::v2_lr_group",
+    "EulerSR::v3_lr_group",
+    "EulerSR::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_reconstruct_3", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulersr_cons_calc_reconstruct_3", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulersr_cons_calc_reconstruct_3_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulersr_cons_calc_reconstruct_3_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_rhs_1.cc b/Examples/EulerSR/src/eulersr_cons_calc_rhs_1.cc
index f5ca0d1..cfcf0cb 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_rhs_1.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_rhs_1.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulersr_cons_calc_rhs_1_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -46,8 +46,6 @@ static void eulersr_cons_calc_rhs_1_Body(cGH const * restrict const cctkGH, int
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -90,9 +88,9 @@ static void eulersr_cons_calc_rhs_1_Body(cGH const * restrict const cctkGH, int
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_rhs_1,
+  CCTK_LOOP3(eulersr_cons_calc_rhs_1,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -137,7 +135,7 @@ static void eulersr_cons_calc_rhs_1_Body(cGH const * restrict const cctkGH, int
     S3rhs[index] = S3rhsL;
     taurhs[index] = taurhsL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_rhs_1);
+  CCTK_ENDLOOP3(eulersr_cons_calc_rhs_1);
 }
 
 extern "C" void eulersr_cons_calc_rhs_1(CCTK_ARGUMENTS)
@@ -156,12 +154,20 @@ extern "C" void eulersr_cons_calc_rhs_1(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_flux_group","EulerSR::Den_grouprhs","EulerSR::S1_flux_group","EulerSR::S2_flux_group","EulerSR::S3_flux_group","EulerSR::S_grouprhs","EulerSR::tau_flux_group","EulerSR::tau_grouprhs"};
+  const char *const groups[] = {
+    "EulerSR::Den_flux_group",
+    "EulerSR::Den_grouprhs",
+    "EulerSR::S1_flux_group",
+    "EulerSR::S2_flux_group",
+    "EulerSR::S3_flux_group",
+    "EulerSR::S_grouprhs",
+    "EulerSR::tau_flux_group",
+    "EulerSR::tau_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_rhs_1", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulersr_cons_calc_rhs_1", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulersr_cons_calc_rhs_1_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulersr_cons_calc_rhs_1_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_rhs_2.cc b/Examples/EulerSR/src/eulersr_cons_calc_rhs_2.cc
index 33d6d0e..e5ca803 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_rhs_2.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_rhs_2.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulersr_cons_calc_rhs_2_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -46,8 +46,6 @@ static void eulersr_cons_calc_rhs_2_Body(cGH const * restrict const cctkGH, int
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -90,9 +88,9 @@ static void eulersr_cons_calc_rhs_2_Body(cGH const * restrict const cctkGH, int
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_rhs_2,
+  CCTK_LOOP3(eulersr_cons_calc_rhs_2,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -137,7 +135,7 @@ static void eulersr_cons_calc_rhs_2_Body(cGH const * restrict const cctkGH, int
     S3rhs[index] = S3rhsL;
     taurhs[index] = taurhsL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_rhs_2);
+  CCTK_ENDLOOP3(eulersr_cons_calc_rhs_2);
 }
 
 extern "C" void eulersr_cons_calc_rhs_2(CCTK_ARGUMENTS)
@@ -156,12 +154,20 @@ extern "C" void eulersr_cons_calc_rhs_2(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_flux_group","EulerSR::Den_grouprhs","EulerSR::S1_flux_group","EulerSR::S2_flux_group","EulerSR::S3_flux_group","EulerSR::S_grouprhs","EulerSR::tau_flux_group","EulerSR::tau_grouprhs"};
+  const char *const groups[] = {
+    "EulerSR::Den_flux_group",
+    "EulerSR::Den_grouprhs",
+    "EulerSR::S1_flux_group",
+    "EulerSR::S2_flux_group",
+    "EulerSR::S3_flux_group",
+    "EulerSR::S_grouprhs",
+    "EulerSR::tau_flux_group",
+    "EulerSR::tau_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_rhs_2", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulersr_cons_calc_rhs_2", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulersr_cons_calc_rhs_2_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulersr_cons_calc_rhs_2_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_rhs_3.cc b/Examples/EulerSR/src/eulersr_cons_calc_rhs_3.cc
index 6a288fe..b494cdc 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_rhs_3.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_rhs_3.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void eulersr_cons_calc_rhs_3_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -46,8 +46,6 @@ static void eulersr_cons_calc_rhs_3_Body(cGH const * restrict const cctkGH, int
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -90,9 +88,9 @@ static void eulersr_cons_calc_rhs_3_Body(cGH const * restrict const cctkGH, int
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_rhs_3,
+  CCTK_LOOP3(eulersr_cons_calc_rhs_3,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -137,7 +135,7 @@ static void eulersr_cons_calc_rhs_3_Body(cGH const * restrict const cctkGH, int
     S3rhs[index] = S3rhsL;
     taurhs[index] = taurhsL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_rhs_3);
+  CCTK_ENDLOOP3(eulersr_cons_calc_rhs_3);
 }
 
 extern "C" void eulersr_cons_calc_rhs_3(CCTK_ARGUMENTS)
@@ -156,12 +154,20 @@ extern "C" void eulersr_cons_calc_rhs_3(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_flux_group","EulerSR::Den_grouprhs","EulerSR::S1_flux_group","EulerSR::S2_flux_group","EulerSR::S3_flux_group","EulerSR::S_grouprhs","EulerSR::tau_flux_group","EulerSR::tau_grouprhs"};
+  const char *const groups[] = {
+    "EulerSR::Den_flux_group",
+    "EulerSR::Den_grouprhs",
+    "EulerSR::S1_flux_group",
+    "EulerSR::S2_flux_group",
+    "EulerSR::S3_flux_group",
+    "EulerSR::S_grouprhs",
+    "EulerSR::tau_flux_group",
+    "EulerSR::tau_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_rhs_3", 8, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "eulersr_cons_calc_rhs_3", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &eulersr_cons_calc_rhs_3_Body);
+  GenericFD_LoopOverInterior(cctkGH, eulersr_cons_calc_rhs_3_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_cons_calc_zero_rhs.cc b/Examples/EulerSR/src/eulersr_cons_calc_zero_rhs.cc
index 6a93d61..382e07c 100644
--- a/Examples/EulerSR/src/eulersr_cons_calc_zero_rhs.cc
+++ b/Examples/EulerSR/src/eulersr_cons_calc_zero_rhs.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulersr_cons_calc_zero_rhs_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulersr_cons_calc_zero_rhs_Body(cGH const * restrict const cctkGH, i
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulersr_cons_calc_zero_rhs_Body(cGH const * restrict const cctkGH, i
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_cons_calc_zero_rhs,
+  CCTK_LOOP3(eulersr_cons_calc_zero_rhs,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -124,7 +122,7 @@ static void eulersr_cons_calc_zero_rhs_Body(cGH const * restrict const cctkGH, i
     S3rhs[index] = S3rhsL;
     taurhs[index] = taurhsL;
   }
-  CCTK_ENDLOOP3 (eulersr_cons_calc_zero_rhs);
+  CCTK_ENDLOOP3(eulersr_cons_calc_zero_rhs);
 }
 
 extern "C" void eulersr_cons_calc_zero_rhs(CCTK_ARGUMENTS)
@@ -143,11 +141,14 @@ extern "C" void eulersr_cons_calc_zero_rhs(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::Den_grouprhs","EulerSR::S_grouprhs","EulerSR::tau_grouprhs"};
+  const char *const groups[] = {
+    "EulerSR::Den_grouprhs",
+    "EulerSR::S_grouprhs",
+    "EulerSR::tau_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_cons_calc_zero_rhs", 3, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulersr_cons_calc_zero_rhs_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulersr_cons_calc_zero_rhs_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/eulersr_initial_shock.cc b/Examples/EulerSR/src/eulersr_initial_shock.cc
index 73eb475..80a8705 100644
--- a/Examples/EulerSR/src/eulersr_initial_shock.cc
+++ b/Examples/EulerSR/src/eulersr_initial_shock.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void eulersr_initial_shock_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void eulersr_initial_shock_Body(cGH const * restrict const cctkGH, int co
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,9 +70,9 @@ static void eulersr_initial_shock_Body(cGH const * restrict const cctkGH, int co
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (eulersr_initial_shock,
+  CCTK_LOOP3(eulersr_initial_shock,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -112,7 +110,7 @@ static void eulersr_initial_shock_Body(cGH const * restrict const cctkGH, int co
     v2[index] = v2L;
     v3[index] = v3L;
   }
-  CCTK_ENDLOOP3 (eulersr_initial_shock);
+  CCTK_ENDLOOP3(eulersr_initial_shock);
 }
 
 extern "C" void eulersr_initial_shock(CCTK_ARGUMENTS)
@@ -131,11 +129,15 @@ extern "C" void eulersr_initial_shock(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"EulerSR::epsi_group","grid::coordinates","EulerSR::rho_group","EulerSR::v_group"};
+  const char *const groups[] = {
+    "EulerSR::epsi_group",
+    "grid::coordinates",
+    "EulerSR::rho_group",
+    "EulerSR::v_group"};
   GenericFD_AssertGroupStorage(cctkGH, "eulersr_initial_shock", 4, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &eulersr_initial_shock_Body);
+  GenericFD_LoopOverEverything(cctkGH, eulersr_initial_shock_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/EulerSR/src/make.code.defn b/Examples/EulerSR/src/make.code.defn
index ec747ad..9641a96 100644
--- a/Examples/EulerSR/src/make.code.defn
+++ b/Examples/EulerSR/src/make.code.defn
@@ -1,3 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc eulersr_initial_shock.cc eulersr_cons_calc_zero_rhs.cc eulersr_cons_calc_conserved.cc eulersr_cons_calc_primitives.cc eulersr_cons_calc_reconstruct_1.cc eulersr_cons_calc_intercell_conserved_1.cc eulersr_cons_calc_flux_1.cc eulersr_cons_calc_rhs_1.cc eulersr_cons_calc_reconstruct_2.cc eulersr_cons_calc_intercell_conserved_2.cc eulersr_cons_calc_flux_2.cc eulersr_cons_calc_rhs_2.cc eulersr_cons_calc_reconstruct_3.cc eulersr_cons_calc_intercell_conserved_3.cc eulersr_cons_calc_flux_3.cc eulersr_cons_calc_rhs_3.cc Boundaries.cc 
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc eulersr_initial_shock.cc eulersr_cons_calc_zero_rhs.cc eulersr_cons_calc_conserved.cc eulersr_cons_calc_primitives.cc eulersr_cons_calc_reconstruct_1.cc eulersr_cons_calc_intercell_conserved_1.cc eulersr_cons_calc_flux_1.cc eulersr_cons_calc_rhs_1.cc eulersr_cons_calc_reconstruct_2.cc eulersr_cons_calc_intercell_conserved_2.cc eulersr_cons_calc_flux_2.cc eulersr_cons_calc_rhs_2.cc eulersr_cons_calc_reconstruct_3.cc eulersr_cons_calc_intercell_conserved_3.cc eulersr_cons_calc_flux_3.cc eulersr_cons_calc_rhs_3.cc Boundaries.cc 
diff --git a/Examples/Laplace/schedule.ccl b/Examples/Laplace/schedule.ccl
index 782b1e6..05344ed 100644
--- a/Examples/Laplace/schedule.ccl
+++ b/Examples/Laplace/schedule.ccl
@@ -33,12 +33,6 @@ schedule Laplace_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule Laplace_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule Laplace_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
@@ -49,34 +43,45 @@ schedule Laplace_initial AT INITIAL
 {
   LANG: C
   SYNC: phi_group
+  READS:    grid::x
+  READS:    grid::y
+  WRITES:   Laplace::phi
 } "Laplace_initial"
 
 schedule Laplace_initial_boundary AT INITIAL after Laplace_initial
 {
   LANG: C
   SYNC: phi_group
+  READS:    grid::y
+  WRITES:   Laplace::phi
 } "Laplace_initial_boundary"
 
 schedule Laplace_relax in MoL_CalcRHS
 {
   LANG: C
+  READS:    Laplace::phi
+  WRITES:   Laplace::phirhs
 } "Laplace_relax"
 
 schedule Laplace_relax AT ANALYSIS
 {
   LANG: C
   SYNC: phi_grouprhs
+  READS:    Laplace::phi
+  WRITES:   Laplace::phirhs
 } "Laplace_relax"
 
 schedule Laplace_boundary in MoL_RHSBoundaries
 {
   LANG: C
+  WRITES:   Laplace::phirhs
 } "Laplace_boundary"
 
 schedule Laplace_boundary AT ANALYSIS
 {
   LANG: C
   SYNC: phi_grouprhs
+  WRITES:   Laplace::phirhs
 } "Laplace_boundary"
 
 schedule Laplace_SelectBoundConds in MoL_PostStep
@@ -92,6 +97,12 @@ schedule Laplace_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
+schedule Laplace_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
 schedule group ApplyBCs as Laplace_ApplyBCs in MoL_PostStep after Laplace_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/Laplace/src/Laplace_boundary.cc b/Examples/Laplace/src/Laplace_boundary.cc
index 1c8ee2d..ffec3ce 100644
--- a/Examples/Laplace/src/Laplace_boundary.cc
+++ b/Examples/Laplace/src/Laplace_boundary.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void Laplace_boundary_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void Laplace_boundary_Body(cGH const * restrict const cctkGH, int const d
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,10 +70,10 @@ static void Laplace_boundary_Body(cGH const * restrict const cctkGH, int const d
   CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
@@ -91,9 +89,9 @@ static void Laplace_boundary_Body(cGH const * restrict const cctkGH, int const d
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (Laplace_boundary,
+  CCTK_LOOP3(Laplace_boundary,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -120,7 +118,7 @@ static void Laplace_boundary_Body(cGH const * restrict const cctkGH, int const d
     /* Copy local copies back to grid functions */
     phirhs[index] = phirhsL;
   }
-  CCTK_ENDLOOP3 (Laplace_boundary);
+  CCTK_ENDLOOP3(Laplace_boundary);
 }
 
 extern "C" void Laplace_boundary(CCTK_ARGUMENTS)
@@ -139,7 +137,8 @@ extern "C" void Laplace_boundary(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Laplace::phi_grouprhs"};
+  const char *const groups[] = {
+    "Laplace::phi_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "Laplace_boundary", 1, groups);
   
   switch(fdOrder)
@@ -151,7 +150,7 @@ extern "C" void Laplace_boundary(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverBoundary(cctkGH, &Laplace_boundary_Body);
+  GenericFD_LoopOverBoundary(cctkGH, Laplace_boundary_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Laplace/src/Laplace_initial.cc b/Examples/Laplace/src/Laplace_initial.cc
index f334d59..0e31009 100644
--- a/Examples/Laplace/src/Laplace_initial.cc
+++ b/Examples/Laplace/src/Laplace_initial.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void Laplace_initial_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void Laplace_initial_Body(cGH const * restrict const cctkGH, int const di
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,10 +70,10 @@ static void Laplace_initial_Body(cGH const * restrict const cctkGH, int const di
   CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
@@ -91,9 +89,9 @@ static void Laplace_initial_Body(cGH const * restrict const cctkGH, int const di
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (Laplace_initial,
+  CCTK_LOOP3(Laplace_initial,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -118,12 +116,12 @@ static void Laplace_initial_Body(cGH const * restrict const cctkGH, int const di
     
     /* Calculate temporaries and grid functions */
     CCTK_REAL phiL = 
-      4*Csch(Pi*INV(ToReal(Lx))*ToReal(Ly))*INV(Pi)*Sin(xL*Pi*INV(ToReal(Lx)))*Sinh(yL*Pi*INV(ToReal(Lx)))*ToReal(phi0);
+      4*cosh(yL*Pi*INV(ToReal(Lx)))*INV(Pi)*INV(sinh(Pi*INV(ToReal(Lx))*ToReal(Ly)))*sin(xL*Pi*INV(ToReal(Lx)))*ToReal(phi0);
     
     /* Copy local copies back to grid functions */
     phi[index] = phiL;
   }
-  CCTK_ENDLOOP3 (Laplace_initial);
+  CCTK_ENDLOOP3(Laplace_initial);
 }
 
 extern "C" void Laplace_initial(CCTK_ARGUMENTS)
@@ -142,7 +140,9 @@ extern "C" void Laplace_initial(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"grid::coordinates","Laplace::phi_group"};
+  const char *const groups[] = {
+    "grid::coordinates",
+    "Laplace::phi_group"};
   GenericFD_AssertGroupStorage(cctkGH, "Laplace_initial", 2, groups);
   
   switch(fdOrder)
@@ -154,7 +154,7 @@ extern "C" void Laplace_initial(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverInterior(cctkGH, &Laplace_initial_Body);
+  GenericFD_LoopOverInterior(cctkGH, Laplace_initial_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Laplace/src/Laplace_initial_boundary.cc b/Examples/Laplace/src/Laplace_initial_boundary.cc
index 2e288c5..b69fe52 100644
--- a/Examples/Laplace/src/Laplace_initial_boundary.cc
+++ b/Examples/Laplace/src/Laplace_initial_boundary.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void Laplace_initial_boundary_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void Laplace_initial_boundary_Body(cGH const * restrict const cctkGH, int
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,10 +70,10 @@ static void Laplace_initial_boundary_Body(cGH const * restrict const cctkGH, int
   CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
@@ -91,9 +89,9 @@ static void Laplace_initial_boundary_Body(cGH const * restrict const cctkGH, int
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (Laplace_initial_boundary,
+  CCTK_LOOP3(Laplace_initial_boundary,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -116,13 +114,13 @@ static void Laplace_initial_boundary_Body(cGH const * restrict const cctkGH, int
     }
     
     /* Calculate temporaries and grid functions */
-    CCTK_REAL phiL = IfThen(10000000000*Abs(-yL + Ly) < 
+    CCTK_REAL phiL = IfThen(10000000000*fabs(-yL + Ly) < 
       1,ToReal(phi0),0);
     
     /* Copy local copies back to grid functions */
     phi[index] = phiL;
   }
-  CCTK_ENDLOOP3 (Laplace_initial_boundary);
+  CCTK_ENDLOOP3(Laplace_initial_boundary);
 }
 
 extern "C" void Laplace_initial_boundary(CCTK_ARGUMENTS)
@@ -141,7 +139,9 @@ extern "C" void Laplace_initial_boundary(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"grid::coordinates","Laplace::phi_group"};
+  const char *const groups[] = {
+    "grid::coordinates",
+    "Laplace::phi_group"};
   GenericFD_AssertGroupStorage(cctkGH, "Laplace_initial_boundary", 2, groups);
   
   switch(fdOrder)
@@ -153,7 +153,7 @@ extern "C" void Laplace_initial_boundary(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverBoundary(cctkGH, &Laplace_initial_boundary_Body);
+  GenericFD_LoopOverBoundary(cctkGH, Laplace_initial_boundary_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Laplace/src/Laplace_relax.cc b/Examples/Laplace/src/Laplace_relax.cc
index db6d9c3..a5cb16c 100644
--- a/Examples/Laplace/src/Laplace_relax.cc
+++ b/Examples/Laplace/src/Laplace_relax.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void Laplace_relax_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void Laplace_relax_Body(cGH const * restrict const cctkGH, int const dir,
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -72,10 +70,10 @@ static void Laplace_relax_Body(cGH const * restrict const cctkGH, int const dir,
   CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const pm1o12dx2 = -0.0833333333333333333333333333333*INV(SQR(dx));
@@ -91,9 +89,9 @@ static void Laplace_relax_Body(cGH const * restrict const cctkGH, int const dir,
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (Laplace_relax,
+  CCTK_LOOP3(Laplace_relax,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -131,7 +129,7 @@ static void Laplace_relax_Body(cGH const * restrict const cctkGH, int const dir,
     /* Copy local copies back to grid functions */
     phirhs[index] = phirhsL;
   }
-  CCTK_ENDLOOP3 (Laplace_relax);
+  CCTK_ENDLOOP3(Laplace_relax);
 }
 
 extern "C" void Laplace_relax(CCTK_ARGUMENTS)
@@ -150,7 +148,9 @@ extern "C" void Laplace_relax(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Laplace::phi_group","Laplace::phi_grouprhs"};
+  const char *const groups[] = {
+    "Laplace::phi_group",
+    "Laplace::phi_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "Laplace_relax", 2, groups);
   
   switch(fdOrder)
@@ -164,7 +164,7 @@ extern "C" void Laplace_relax(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverInterior(cctkGH, &Laplace_relax_Body);
+  GenericFD_LoopOverInterior(cctkGH, Laplace_relax_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Laplace/src/make.code.defn b/Examples/Laplace/src/make.code.defn
index 7ced3ce..d65a37f 100644
--- a/Examples/Laplace/src/make.code.defn
+++ b/Examples/Laplace/src/make.code.defn
@@ -1,3 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc Laplace_initial.cc Laplace_initial_boundary.cc Laplace_relax.cc Laplace_boundary.cc Boundaries.cc 
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc Laplace_initial.cc Laplace_initial_boundary.cc Laplace_relax.cc Laplace_boundary.cc Boundaries.cc 
diff --git a/Examples/Makefile b/Examples/Makefile
index d983462..191b0f2 100644
--- a/Examples/Makefile
+++ b/Examples/Makefile
@@ -1,5 +1,8 @@
 thornscripts = $(wildcard *.m)
-thorns = ${thornscripts:.m=}
+
+# thorns = ${thornscripts:.m=}
+
+thorns = $(shell cat make.thorns)
 
 kranc = ../Bin/kranc
 
diff --git a/Examples/SimpleWave/schedule.ccl b/Examples/SimpleWave/schedule.ccl
index d5e8e4c..853e2ea 100644
--- a/Examples/SimpleWave/schedule.ccl
+++ b/Examples/SimpleWave/schedule.ccl
@@ -33,12 +33,6 @@ schedule SimpleWave_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule SimpleWave_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule SimpleWave_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
@@ -48,11 +42,18 @@ schedule SimpleWave_RegisterSymmetries in SymmetryRegister
 schedule initial_sine AT INITIAL
 {
   LANG: C
+  READS:    grid::x
+  WRITES:   SimpleWave::phi
+  WRITES:   SimpleWave::pi
 } "initial_sine"
 
 schedule calc_rhs in MoL_CalcRHS
 {
   LANG: C
+  READS:    SimpleWave::phi
+  READS:    SimpleWave::pi
+  WRITES:   SimpleWave::phirhs
+  WRITES:   SimpleWave::pirhs
 } "calc_rhs"
 
 schedule SimpleWave_SelectBoundConds in MoL_PostStep
@@ -68,6 +69,12 @@ schedule SimpleWave_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
+schedule SimpleWave_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
 schedule group ApplyBCs as SimpleWave_ApplyBCs in MoL_PostStep after SimpleWave_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/SimpleWave/src/calc_rhs.cc b/Examples/SimpleWave/src/calc_rhs.cc
index f2af270..4a5d002 100644
--- a/Examples/SimpleWave/src/calc_rhs.cc
+++ b/Examples/SimpleWave/src/calc_rhs.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void calc_rhs_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void calc_rhs_Body(cGH const * restrict const cctkGH, int const dir, int
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -86,9 +84,9 @@ static void calc_rhs_Body(cGH const * restrict const cctkGH, int const dir, int
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (calc_rhs,
+  CCTK_LOOP3(calc_rhs,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -115,7 +113,7 @@ static void calc_rhs_Body(cGH const * restrict const cctkGH, int const dir, int
     phirhs[index] = phirhsL;
     pirhs[index] = pirhsL;
   }
-  CCTK_ENDLOOP3 (calc_rhs);
+  CCTK_ENDLOOP3(calc_rhs);
 }
 
 extern "C" void calc_rhs(CCTK_ARGUMENTS)
@@ -134,12 +132,14 @@ extern "C" void calc_rhs(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"SimpleWave::evolved_group","SimpleWave::evolved_grouprhs"};
+  const char *const groups[] = {
+    "SimpleWave::evolved_group",
+    "SimpleWave::evolved_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "calc_rhs", 2, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "calc_rhs", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &calc_rhs_Body);
+  GenericFD_LoopOverInterior(cctkGH, calc_rhs_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/SimpleWave/src/initial_sine.cc b/Examples/SimpleWave/src/initial_sine.cc
index c8a5656..cae7f0a 100644
--- a/Examples/SimpleWave/src/initial_sine.cc
+++ b/Examples/SimpleWave/src/initial_sine.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void initial_sine_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void initial_sine_Body(cGH const * restrict const cctkGH, int const dir,
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -74,9 +72,9 @@ static void initial_sine_Body(cGH const * restrict const cctkGH, int const dir,
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (initial_sine,
+  CCTK_LOOP3(initial_sine,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -90,15 +88,15 @@ static void initial_sine_Body(cGH const * restrict const cctkGH, int const dir,
     /* Precompute derivatives */
     
     /* Calculate temporaries and grid functions */
-    CCTK_REAL phiL = Sin(2*Pi*(xL - cctk_time));
+    CCTK_REAL phiL = sin(2*Pi*(xL - t));
     
-    CCTK_REAL piL = -2*Pi*Cos(2*Pi*(xL - cctk_time));
+    CCTK_REAL piL = -2*Pi*cos(2*Pi*(xL - t));
     
     /* Copy local copies back to grid functions */
     phi[index] = phiL;
     pi[index] = piL;
   }
-  CCTK_ENDLOOP3 (initial_sine);
+  CCTK_ENDLOOP3(initial_sine);
 }
 
 extern "C" void initial_sine(CCTK_ARGUMENTS)
@@ -117,11 +115,13 @@ extern "C" void initial_sine(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"SimpleWave::evolved_group","grid::coordinates"};
+  const char *const groups[] = {
+    "SimpleWave::evolved_group",
+    "grid::coordinates"};
   GenericFD_AssertGroupStorage(cctkGH, "initial_sine", 2, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &initial_sine_Body);
+  GenericFD_LoopOverEverything(cctkGH, initial_sine_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/SimpleWave/src/make.code.defn b/Examples/SimpleWave/src/make.code.defn
index 535f5d0..3332924 100644
--- a/Examples/SimpleWave/src/make.code.defn
+++ b/Examples/SimpleWave/src/make.code.defn
@@ -1,3 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc initial_sine.cc calc_rhs.cc Boundaries.cc 
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc initial_sine.cc calc_rhs.cc Boundaries.cc 
diff --git a/Examples/SimpleWaveODE/configuration.ccl b/Examples/SimpleWaveODE/configuration.ccl
new file mode 100644
index 0000000..0a66ec2
--- /dev/null
+++ b/Examples/SimpleWaveODE/configuration.ccl
@@ -0,0 +1,6 @@
+# File produced by Kranc
+
+REQUIRES GenericFD
+OPTIONAL LoopControl
+{
+}
diff --git a/Examples/SimpleWaveODE/interface.ccl b/Examples/SimpleWaveODE/interface.ccl
new file mode 100644
index 0000000..cd7bee1
--- /dev/null
+++ b/Examples/SimpleWaveODE/interface.ccl
@@ -0,0 +1,56 @@
+# File produced by Kranc
+
+implements: SimpleWaveODE
+
+inherits:   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
+
+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 MultiPatch_GetMap(CCTK_POINTER_TO_CONST IN cctkGH)
+USES FUNCTION MultiPatch_GetMap
+
+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 evolved_group type=GF timelevels=3 tags=''
+{
+  phi,
+  pi
+} "evolved_group"
+
+public:
+CCTK_REAL evolved_grouprhs type=GF timelevels=3 tags=''
+{
+  phirhs,
+  pirhs
+} "evolved_grouprhs"
+
+public:
+CCTK_REAL ode_group type=array timelevels=3 tags='' dim=1 size=1
+{
+  a,
+  b
+} "ode_group"
+
+public:
+CCTK_REAL ode_grouprhs type=array timelevels=3 tags='' dim=1 size=1
+{
+  arhs,
+  brhs
+} "ode_grouprhs"
diff --git a/Examples/SimpleWaveODE/param.ccl b/Examples/SimpleWaveODE/param.ccl
new file mode 100644
index 0000000..47f5db0
--- /dev/null
+++ b/Examples/SimpleWaveODE/param.ccl
@@ -0,0 +1,162 @@
+# File produced by Kranc
+
+
+shares: GenericFD
+
+
+
+shares: MethodOfLines
+
+USES CCTK_INT MoL_Num_Evolved_Vars
+USES CCTK_INT MoL_Num_ArrayEvolved_Vars
+
+restricted:
+CCTK_INT verbose "verbose" STEERABLE=ALWAYS
+{
+  *:* :: ""
+} 0
+
+restricted:
+CCTK_INT SimpleWaveODE_MaxNumEvolvedVars "Number of evolved variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_Evolved_Vars STEERABLE=RECOVER
+{
+  2:2 :: "Number of evolved variables used by this thorn"
+} 2
+
+restricted:
+CCTK_INT SimpleWaveODE_MaxNumArrayEvolvedVars "Number of Array evolved variables used by this thorn" ACCUMULATOR-BASE=MethodofLines::MoL_Num_ArrayEvolved_Vars STEERABLE=RECOVER
+{
+  2:2 :: "Number of Array evolved variables used by this thorn"
+} 2
+
+restricted:
+CCTK_INT timelevels "Number of active timelevels" STEERABLE=RECOVER
+{
+  0:3 :: ""
+} 3
+
+restricted:
+CCTK_INT rhs_timelevels "Number of active RHS timelevels" STEERABLE=RECOVER
+{
+  0:3 :: ""
+} 1
+
+restricted:
+CCTK_INT other_timelevels "Number of active timelevels for non-evolved grid functions" STEERABLE=RECOVER
+{
+  0:3 :: ""
+} 1
+
+restricted:
+CCTK_INT initial_sine_calc_every "initial_sine_calc_every" STEERABLE=ALWAYS
+{
+  *:* :: ""
+} 1
+
+restricted:
+CCTK_INT calc_rhs_calc_every "calc_rhs_calc_every" STEERABLE=ALWAYS
+{
+  *:* :: ""
+} 1
+
+restricted:
+CCTK_INT initial_sine_calc_offset "initial_sine_calc_offset" STEERABLE=ALWAYS
+{
+  *:* :: ""
+} 0
+
+restricted:
+CCTK_INT calc_rhs_calc_offset "calc_rhs_calc_offset" STEERABLE=ALWAYS
+{
+  *:* :: ""
+} 0
+
+private:
+KEYWORD phi_bound "Boundary condition to implement" STEERABLE=ALWAYS
+{
+  "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 pi_bound "Boundary condition to implement" STEERABLE=ALWAYS
+{
+  "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 evolved_group_bound "Boundary condition to implement" STEERABLE=ALWAYS
+{
+  "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"
+} "none"
+
+private:
+CCTK_REAL phi_bound_speed "characteristic speed at boundary" STEERABLE=ALWAYS
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL pi_bound_speed "characteristic speed at boundary" STEERABLE=ALWAYS
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL evolved_group_bound_speed "characteristic speed at boundary" STEERABLE=ALWAYS
+{
+  "0:*" :: "outgoing characteristic speed > 0"
+} 1.
+
+private:
+CCTK_REAL phi_bound_limit "limit value for r -> infinity" STEERABLE=ALWAYS
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL pi_bound_limit "limit value for r -> infinity" STEERABLE=ALWAYS
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL evolved_group_bound_limit "limit value for r -> infinity" STEERABLE=ALWAYS
+{
+  "*:*" :: "value of limit value is unrestricted"
+} 0.
+
+private:
+CCTK_REAL phi_bound_scalar "Dirichlet boundary value" STEERABLE=ALWAYS
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL pi_bound_scalar "Dirichlet boundary value" STEERABLE=ALWAYS
+{
+  "*:*" :: "unrestricted"
+} 0.
+
+private:
+CCTK_REAL evolved_group_bound_scalar "Dirichlet boundary value" STEERABLE=ALWAYS
+{
+  "*:*" :: "unrestricted"
+} 0.
+
diff --git a/Examples/SimpleWaveODE/schedule.ccl b/Examples/SimpleWaveODE/schedule.ccl
new file mode 100644
index 0000000..65afd16
--- /dev/null
+++ b/Examples/SimpleWaveODE/schedule.ccl
@@ -0,0 +1,114 @@
+# File produced by Kranc
+
+
+if (timelevels == 1)
+{
+  STORAGE: evolved_group[1]
+}
+if (timelevels == 2)
+{
+  STORAGE: evolved_group[2]
+}
+if (timelevels == 3)
+{
+  STORAGE: evolved_group[3]
+}
+
+if (timelevels == 1)
+{
+  STORAGE: ode_group[1]
+}
+if (timelevels == 2)
+{
+  STORAGE: ode_group[2]
+}
+if (timelevels == 3)
+{
+  STORAGE: ode_group[3]
+}
+
+if (rhs_timelevels == 1)
+{
+  STORAGE: evolved_grouprhs[1]
+}
+if (rhs_timelevels == 2)
+{
+  STORAGE: evolved_grouprhs[2]
+}
+if (rhs_timelevels == 3)
+{
+  STORAGE: evolved_grouprhs[3]
+}
+
+if (rhs_timelevels == 1)
+{
+  STORAGE: ode_grouprhs[1]
+}
+if (rhs_timelevels == 2)
+{
+  STORAGE: ode_grouprhs[2]
+}
+if (rhs_timelevels == 3)
+{
+  STORAGE: ode_grouprhs[3]
+}
+
+schedule SimpleWaveODE_Startup at STARTUP
+{
+  LANG: C
+  OPTIONS: meta
+} "create banner"
+
+schedule SimpleWaveODE_RegisterSymmetries in SymmetryRegister
+{
+  LANG: C
+  OPTIONS: meta
+} "register symmetries"
+
+schedule initial_sine AT INITIAL
+{
+  LANG: C
+  READS:    grid::x
+  WRITES:   SimpleWaveODE::a
+  WRITES:   SimpleWaveODE::b
+  WRITES:   SimpleWaveODE::phi
+  WRITES:   SimpleWaveODE::pi
+} "initial_sine"
+
+schedule calc_rhs in MoL_CalcRHS
+{
+  LANG: C
+  READS:    SimpleWaveODE::a
+  READS:    SimpleWaveODE::b
+  READS:    SimpleWaveODE::phi
+  READS:    SimpleWaveODE::pi
+  WRITES:   SimpleWaveODE::arhs
+  WRITES:   SimpleWaveODE::brhs
+  WRITES:   SimpleWaveODE::phirhs
+  WRITES:   SimpleWaveODE::pirhs
+} "calc_rhs"
+
+schedule SimpleWaveODE_SelectBoundConds in MoL_PostStep
+{
+  LANG: C
+  OPTIONS: level
+  SYNC: evolved_group
+  SYNC: ode_group
+} "select boundary conditions"
+
+schedule SimpleWaveODE_CheckBoundaries at BASEGRID
+{
+  LANG: C
+  OPTIONS: meta
+} "check boundaries treatment"
+
+schedule SimpleWaveODE_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
+schedule group ApplyBCs as SimpleWaveODE_ApplyBCs in MoL_PostStep after SimpleWaveODE_SelectBoundConds
+{
+  # no language specified
+} "Apply boundary conditions controlled by thorn Boundary"
diff --git a/Examples/SimpleWaveODE/src/Boundaries.cc b/Examples/SimpleWaveODE/src/Boundaries.cc
new file mode 100644
index 0000000..2172e3c
--- /dev/null
+++ b/Examples/SimpleWaveODE/src/Boundaries.cc
@@ -0,0 +1,197 @@
+/*  File produced by Kranc */
+
+#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      */
+
+
+extern "C" void SimpleWaveODE_CheckBoundaries(CCTK_ARGUMENTS)
+{
+  DECLARE_CCTK_ARGUMENTS;
+  DECLARE_CCTK_PARAMETERS;
+  
+  return;
+}
+
+extern "C" void SimpleWaveODE_SelectBoundConds(CCTK_ARGUMENTS)
+{
+  DECLARE_CCTK_ARGUMENTS;
+  DECLARE_CCTK_PARAMETERS;
+  
+  CCTK_INT ierr = 0;
+  
+  if (CCTK_EQUALS(evolved_group_bound, "none"  ) ||
+      CCTK_EQUALS(evolved_group_bound, "static") ||
+      CCTK_EQUALS(evolved_group_bound, "flat"  ) ||
+      CCTK_EQUALS(evolved_group_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "SimpleWaveODE::evolved_group", evolved_group_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register evolved_group_bound BC for SimpleWaveODE::evolved_group!");
+  }
+  
+  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,
+                      "SimpleWaveODE::phi", phi_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register phi_bound BC for SimpleWaveODE::phi!");
+  }
+  
+  if (CCTK_EQUALS(pi_bound, "none"  ) ||
+      CCTK_EQUALS(pi_bound, "static") ||
+      CCTK_EQUALS(pi_bound, "flat"  ) ||
+      CCTK_EQUALS(pi_bound, "zero"  ) )
+  {
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, -1,
+                      "SimpleWaveODE::pi", pi_bound);
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register pi_bound BC for SimpleWaveODE::pi!");
+  }
+  
+  if (CCTK_EQUALS(evolved_group_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_evolved_group_bound = -1;
+    if (handle_evolved_group_bound < 0) handle_evolved_group_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_evolved_group_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_evolved_group_bound , evolved_group_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_evolved_group_bound ,evolved_group_bound_speed, "SPEED") < 0)
+       CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_evolved_group_bound, 
+                      "SimpleWaveODE::evolved_group", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for SimpleWaveODE::evolved_group!");
+  
+  }
+  
+  if (CCTK_EQUALS(phi_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_phi_bound = -1;
+    if (handle_phi_bound < 0) handle_phi_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_phi_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_phi_bound , phi_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_phi_bound ,phi_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_phi_bound, 
+                      "SimpleWaveODE::phi", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for SimpleWaveODE::phi!");
+  
+  }
+  
+  if (CCTK_EQUALS(pi_bound, "radiative"))
+  {
+   /* select radiation boundary condition */
+    static CCTK_INT handle_pi_bound = -1;
+    if (handle_pi_bound < 0) handle_pi_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_pi_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_pi_bound , pi_bound_limit, "LIMIT") < 0)
+       CCTK_WARN(0, "could not set LIMIT value in table!");
+    if (Util_TableSetReal(handle_pi_bound ,pi_bound_speed, "SPEED") < 0)
+        CCTK_WARN(0, "could not set SPEED value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_pi_bound, 
+                      "SimpleWaveODE::pi", "Radiation");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Radiation BC for SimpleWaveODE::pi!");
+  
+  }
+  
+  if (CCTK_EQUALS(evolved_group_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_evolved_group_bound = -1;
+    if (handle_evolved_group_bound < 0) handle_evolved_group_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_evolved_group_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_evolved_group_bound ,evolved_group_bound_scalar, "SCALAR") < 0)
+        CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, 1, handle_evolved_group_bound, 
+                      "SimpleWaveODE::evolved_group", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Failed to register Scalar BC for SimpleWaveODE::evolved_group!");
+  
+  }
+  
+  if (CCTK_EQUALS(phi_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_phi_bound = -1;
+    if (handle_phi_bound < 0) handle_phi_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_phi_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_phi_bound ,phi_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_phi_bound, 
+                      "SimpleWaveODE::phi", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for SimpleWaveODE::phi!");
+  
+  }
+  
+  if (CCTK_EQUALS(pi_bound, "scalar"))
+  {
+   /* select scalar boundary condition */
+    static CCTK_INT handle_pi_bound = -1;
+    if (handle_pi_bound < 0) handle_pi_bound = Util_TableCreate(UTIL_TABLE_FLAGS_CASE_INSENSITIVE);
+    if (handle_pi_bound < 0) CCTK_WARN(0, "could not create table!");
+    if (Util_TableSetReal(handle_pi_bound ,pi_bound_scalar, "SCALAR") < 0)
+      CCTK_WARN(0, "could not set SCALAR value in table!");
+  
+    ierr = Boundary_SelectVarForBC(cctkGH, CCTK_ALL_FACES, 1, handle_pi_bound, 
+                      "SimpleWaveODE::pi", "scalar");
+  
+    if (ierr < 0)
+       CCTK_WARN(0, "Error in registering Scalar BC for SimpleWaveODE::pi!");
+  
+  }
+  return;
+}
+
+
+
+/* template for entries in parameter file:
+#$bound$#SimpleWaveODE::evolved_group_bound       = "skip"
+#$bound$#SimpleWaveODE::evolved_group_bound_speed = 1.0
+#$bound$#SimpleWaveODE::evolved_group_bound_limit = 0.0
+#$bound$#SimpleWaveODE::evolved_group_bound_scalar = 0.0
+
+#$bound$#SimpleWaveODE::phi_bound       = "skip"
+#$bound$#SimpleWaveODE::phi_bound_speed = 1.0
+#$bound$#SimpleWaveODE::phi_bound_limit = 0.0
+#$bound$#SimpleWaveODE::phi_bound_scalar = 0.0
+
+#$bound$#SimpleWaveODE::pi_bound       = "skip"
+#$bound$#SimpleWaveODE::pi_bound_speed = 1.0
+#$bound$#SimpleWaveODE::pi_bound_limit = 0.0
+#$bound$#SimpleWaveODE::pi_bound_scalar = 0.0
+
+*/
+
diff --git a/Examples/SimpleWaveODE/src/Differencing.h b/Examples/SimpleWaveODE/src/Differencing.h
new file mode 100644
index 0000000..ef21b0b
--- /dev/null
+++ b/Examples/SimpleWaveODE/src/Differencing.h
@@ -0,0 +1,72 @@
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd1(u) ((-KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1o2dx)
+#else
+#  define PDstandard2nd1(u) (PDstandard2nd1_impl(u,p1o2dx,cdj,cdk))
+static CCTK_REAL PDstandard2nd1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dx, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dx, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1o2dx;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd2(u) ((-KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1o2dy)
+#else
+#  define PDstandard2nd2(u) (PDstandard2nd2_impl(u,p1o2dy,cdj,cdk))
+static CCTK_REAL PDstandard2nd2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dy, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dy, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1o2dy;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd3(u) ((-KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1))*p1o2dz)
+#else
+#  define PDstandard2nd3(u) (PDstandard2nd3_impl(u,p1o2dz,cdj,cdk))
+static CCTK_REAL PDstandard2nd3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o2dz, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1))*p1o2dz;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd11(u) ((-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1odx2)
+#else
+#  define PDstandard2nd11(u) (PDstandard2nd11_impl(u,p1odx2,cdj,cdk))
+static CCTK_REAL PDstandard2nd11_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odx2, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd11_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odx2, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1odx2;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd22(u) ((-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1ody2)
+#else
+#  define PDstandard2nd22(u) (PDstandard2nd22_impl(u,p1ody2,cdj,cdk))
+static CCTK_REAL PDstandard2nd22_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1ody2, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd22_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1ody2, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1ody2;
+}
+#endif
+
+#ifndef KRANC_DIFF_FUNCTIONS
+#  define PDstandard2nd33(u) ((-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1))*p1odz2)
+#else
+#  define PDstandard2nd33(u) (PDstandard2nd33_impl(u,p1odz2,cdj,cdk))
+static CCTK_REAL PDstandard2nd33_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odz2, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
+static CCTK_REAL PDstandard2nd33_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odz2, ptrdiff_t const cdj, ptrdiff_t const cdk)
+{
+  ptrdiff_t const cdi=sizeof(CCTK_REAL);
+  return (-2*KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1))*p1odz2;
+}
+#endif
+
diff --git a/Examples/SimpleWaveODE/src/RegisterMoL.cc b/Examples/SimpleWaveODE/src/RegisterMoL.cc
new file mode 100644
index 0000000..ecdca33
--- /dev/null
+++ b/Examples/SimpleWaveODE/src/RegisterMoL.cc
@@ -0,0 +1,22 @@
+/*  File produced by Kranc */
+
+#include "cctk.h"
+#include "cctk_Arguments.h"
+#include "cctk_Parameters.h"
+
+extern "C" void SimpleWaveODE_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("SimpleWaveODE::phi"),  CCTK_VarIndex("SimpleWaveODE::phirhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("SimpleWaveODE::pi"),  CCTK_VarIndex("SimpleWaveODE::pirhs"));
+  
+  /* Register all the evolved Array functions with MoL */
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("SimpleWaveODE::a"),  CCTK_VarIndex("SimpleWaveODE::arhs"));
+  ierr += MoLRegisterEvolved(CCTK_VarIndex("SimpleWaveODE::b"),  CCTK_VarIndex("SimpleWaveODE::brhs"));
+  return;
+}
diff --git a/Examples/SimpleWaveODE/src/RegisterSymmetries.cc b/Examples/SimpleWaveODE/src/RegisterSymmetries.cc
new file mode 100644
index 0000000..02cada4
--- /dev/null
+++ b/Examples/SimpleWaveODE/src/RegisterSymmetries.cc
@@ -0,0 +1,29 @@
+/*  File produced by Kranc */
+
+#include "cctk.h"
+#include "cctk_Arguments.h"
+#include "cctk_Parameters.h"
+#include "Symmetry.h"
+
+extern "C" void SimpleWaveODE_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, "SimpleWaveODE::phi");
+  
+  sym[0] = 1;
+  sym[1] = 1;
+  sym[2] = 1;
+  SetCartSymVN(cctkGH, sym, "SimpleWaveODE::pi");
+  
+}
diff --git a/Examples/SimpleWaveODE/src/Startup.cc b/Examples/SimpleWaveODE/src/Startup.cc
new file mode 100644
index 0000000..077390c
--- /dev/null
+++ b/Examples/SimpleWaveODE/src/Startup.cc
@@ -0,0 +1,10 @@
+/*  File produced by Kranc */
+
+#include "cctk.h"
+
+extern "C" int SimpleWaveODE_Startup(void)
+{
+  const char * banner = "SimpleWaveODE";
+  CCTK_RegisterBanner(banner);
+  return 0;
+}
diff --git a/Examples/SimpleWaveODE/src/calc_rhs.cc b/Examples/SimpleWaveODE/src/calc_rhs.cc
new file mode 100644
index 0000000..d0bf6ef
--- /dev/null
+++ b/Examples/SimpleWaveODE/src/calc_rhs.cc
@@ -0,0 +1,160 @@
+/*  File produced by Kranc */
+
+#define KRANC_C
+
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "cctk.h"
+#include "cctk_Arguments.h"
+#include "cctk_Parameters.h"
+#include "GenericFD.h"
+#include "Differencing.h"
+#include "cctk_Loop.h"
+#include "loopcontrol.h"
+
+/* Define macros used in calculations */
+#define INITVALUE (42)
+#define INV(x) ((CCTK_REAL)1.0 / (x))
+#define SQR(x) ((x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
+
+extern "C" void calc_rhs_SelectBCs(CCTK_ARGUMENTS)
+{
+  DECLARE_CCTK_ARGUMENTS;
+  DECLARE_CCTK_PARAMETERS;
+  
+  CCTK_INT ierr = 0;
+  ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, GenericFD_GetBoundaryWidth(cctkGH), -1 /* no table */, "SimpleWaveODE::evolved_grouprhs","flat");
+  if (ierr < 0)
+    CCTK_WARN(1, "Failed to register flat BC for SimpleWaveODE::evolved_grouprhs.");
+  ierr = Boundary_SelectGroupForBC(cctkGH, CCTK_ALL_FACES, GenericFD_GetBoundaryWidth(cctkGH), -1 /* no table */, "SimpleWaveODE::ode_grouprhs","flat");
+  if (ierr < 0)
+    CCTK_WARN(1, "Failed to register flat BC for SimpleWaveODE::ode_grouprhs.");
+  return;
+}
+
+static void calc_rhs_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
+{
+  DECLARE_CCTK_ARGUMENTS;
+  DECLARE_CCTK_PARAMETERS;
+  
+  
+  /* Include user-supplied include files */
+  
+  /* Initialise finite differencing variables */
+  ptrdiff_t const di = 1;
+  ptrdiff_t const dj = CCTK_GFINDEX3D(cctkGH,0,1,0) - CCTK_GFINDEX3D(cctkGH,0,0,0);
+  ptrdiff_t const dk = CCTK_GFINDEX3D(cctkGH,0,0,1) - CCTK_GFINDEX3D(cctkGH,0,0,0);
+  ptrdiff_t const cdi = sizeof(CCTK_REAL) * di;
+  ptrdiff_t const cdj = sizeof(CCTK_REAL) * dj;
+  ptrdiff_t const cdk = sizeof(CCTK_REAL) * dk;
+  CCTK_REAL const dx = ToReal(CCTK_DELTA_SPACE(0));
+  CCTK_REAL const dy = ToReal(CCTK_DELTA_SPACE(1));
+  CCTK_REAL const dz = ToReal(CCTK_DELTA_SPACE(2));
+  CCTK_REAL const dt = ToReal(CCTK_DELTA_TIME);
+  CCTK_REAL const t = ToReal(cctk_time);
+  CCTK_REAL const dxi = INV(dx);
+  CCTK_REAL const dyi = INV(dy);
+  CCTK_REAL const dzi = INV(dz);
+  CCTK_REAL const khalf = 0.5;
+  CCTK_REAL const kthird = 1/3.0;
+  CCTK_REAL const ktwothird = 2.0/3.0;
+  CCTK_REAL const kfourthird = 4.0/3.0;
+  CCTK_REAL const keightthird = 8.0/3.0;
+  CCTK_REAL const hdxi = 0.5 * dxi;
+  CCTK_REAL const hdyi = 0.5 * dyi;
+  CCTK_REAL const hdzi = 0.5 * dzi;
+  
+  /* Initialize predefined quantities */
+  CCTK_REAL const p1o2dx = 0.5*INV(dx);
+  CCTK_REAL const p1o2dy = 0.5*INV(dy);
+  CCTK_REAL const p1o2dz = 0.5*INV(dz);
+  CCTK_REAL const p1odx2 = INV(SQR(dx));
+  CCTK_REAL const p1ody2 = INV(SQR(dy));
+  CCTK_REAL const p1odz2 = INV(SQR(dz));
+  
+  /* Assign local copies of arrays functions */
+  
+  CCTK_REAL aL = a[0];
+  CCTK_REAL bL = b[0];
+  
+  
+  /* Calculate temporaries and arrays functions */
+  CCTK_REAL arhsL = bL;
+  
+  CCTK_REAL brhsL = -aL;
+  
+  /* Copy local copies back to grid functions */
+  arhs[0] = arhsL;
+  brhs[0] = brhsL;
+  
+  /* Loop over the grid points */
+  #pragma omp parallel
+  CCTK_LOOP3(calc_rhs,
+    i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
+  {
+    ptrdiff_t const index = di*i + dj*j + dk*k;
+    
+    /* Assign local copies of grid functions */
+    
+    CCTK_REAL phiL = phi[index];
+    CCTK_REAL piL = pi[index];
+    
+    
+    /* Include user supplied include files */
+    
+    /* Precompute derivatives */
+    CCTK_REAL const PDstandard2nd11phi = PDstandard2nd11(&phi[index]);
+    CCTK_REAL const PDstandard2nd22phi = PDstandard2nd22(&phi[index]);
+    CCTK_REAL const PDstandard2nd33phi = PDstandard2nd33(&phi[index]);
+    
+    /* Calculate temporaries and grid functions */
+    CCTK_REAL phirhsL = piL;
+    
+    CCTK_REAL pirhsL = aL*(PDstandard2nd11phi + PDstandard2nd22phi + 
+      PDstandard2nd33phi);
+    
+    /* Copy local copies back to grid functions */
+    phirhs[index] = phirhsL;
+    pirhs[index] = pirhsL;
+  }
+  CCTK_ENDLOOP3(calc_rhs);
+}
+
+extern "C" void calc_rhs(CCTK_ARGUMENTS)
+{
+  DECLARE_CCTK_ARGUMENTS;
+  DECLARE_CCTK_PARAMETERS;
+  
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Entering calc_rhs_Body");
+  }
+  
+  if (cctk_iteration % calc_rhs_calc_every != calc_rhs_calc_offset)
+  {
+    return;
+  }
+  
+  const char *const groups[] = {
+    "SimpleWaveODE::evolved_group",
+    "SimpleWaveODE::evolved_grouprhs",
+    "SimpleWaveODE::ode_group",
+    "SimpleWaveODE::ode_grouprhs"};
+  GenericFD_AssertGroupStorage(cctkGH, "calc_rhs", 4, groups);
+  
+  GenericFD_EnsureStencilFits(cctkGH, "calc_rhs", 1, 1, 1);
+  
+  GenericFD_LoopOverInterior(cctkGH, calc_rhs_Body);
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Leaving calc_rhs_Body");
+  }
+}
diff --git a/Examples/SimpleWaveODE/src/initial_sine.cc b/Examples/SimpleWaveODE/src/initial_sine.cc
new file mode 100644
index 0000000..0905a98
--- /dev/null
+++ b/Examples/SimpleWaveODE/src/initial_sine.cc
@@ -0,0 +1,136 @@
+/*  File produced by Kranc */
+
+#define KRANC_C
+
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "cctk.h"
+#include "cctk_Arguments.h"
+#include "cctk_Parameters.h"
+#include "GenericFD.h"
+#include "Differencing.h"
+#include "cctk_Loop.h"
+#include "loopcontrol.h"
+
+/* Define macros used in calculations */
+#define INITVALUE (42)
+#define INV(x) ((CCTK_REAL)1.0 / (x))
+#define SQR(x) ((x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
+
+static void initial_sine_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
+{
+  DECLARE_CCTK_ARGUMENTS;
+  DECLARE_CCTK_PARAMETERS;
+  
+  
+  /* Include user-supplied include files */
+  
+  /* Initialise finite differencing variables */
+  ptrdiff_t const di = 1;
+  ptrdiff_t const dj = CCTK_GFINDEX3D(cctkGH,0,1,0) - CCTK_GFINDEX3D(cctkGH,0,0,0);
+  ptrdiff_t const dk = CCTK_GFINDEX3D(cctkGH,0,0,1) - CCTK_GFINDEX3D(cctkGH,0,0,0);
+  ptrdiff_t const cdi = sizeof(CCTK_REAL) * di;
+  ptrdiff_t const cdj = sizeof(CCTK_REAL) * dj;
+  ptrdiff_t const cdk = sizeof(CCTK_REAL) * dk;
+  CCTK_REAL const dx = ToReal(CCTK_DELTA_SPACE(0));
+  CCTK_REAL const dy = ToReal(CCTK_DELTA_SPACE(1));
+  CCTK_REAL const dz = ToReal(CCTK_DELTA_SPACE(2));
+  CCTK_REAL const dt = ToReal(CCTK_DELTA_TIME);
+  CCTK_REAL const t = ToReal(cctk_time);
+  CCTK_REAL const dxi = INV(dx);
+  CCTK_REAL const dyi = INV(dy);
+  CCTK_REAL const dzi = INV(dz);
+  CCTK_REAL const khalf = 0.5;
+  CCTK_REAL const kthird = 1/3.0;
+  CCTK_REAL const ktwothird = 2.0/3.0;
+  CCTK_REAL const kfourthird = 4.0/3.0;
+  CCTK_REAL const keightthird = 8.0/3.0;
+  CCTK_REAL const hdxi = 0.5 * dxi;
+  CCTK_REAL const hdyi = 0.5 * dyi;
+  CCTK_REAL const hdzi = 0.5 * dzi;
+  
+  /* Initialize predefined quantities */
+  CCTK_REAL const p1o2dx = 0.5*INV(dx);
+  CCTK_REAL const p1o2dy = 0.5*INV(dy);
+  CCTK_REAL const p1o2dz = 0.5*INV(dz);
+  CCTK_REAL const p1odx2 = INV(SQR(dx));
+  CCTK_REAL const p1ody2 = INV(SQR(dy));
+  CCTK_REAL const p1odz2 = INV(SQR(dz));
+  
+  /* Assign local copies of arrays functions */
+  
+  
+  
+  /* Calculate temporaries and arrays functions */
+  CCTK_REAL aL = 0;
+  
+  CCTK_REAL bL = 1;
+  
+  /* Copy local copies back to grid functions */
+  a[0] = aL;
+  b[0] = bL;
+  
+  /* Loop over the grid points */
+  #pragma omp parallel
+  CCTK_LOOP3(initial_sine,
+    i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
+  {
+    ptrdiff_t const index = di*i + dj*j + dk*k;
+    
+    /* Assign local copies of grid functions */
+    
+    CCTK_REAL xL = x[index];
+    
+    
+    /* Include user supplied include files */
+    
+    /* Precompute derivatives */
+    
+    /* Calculate temporaries and grid functions */
+    CCTK_REAL phiL = sin(2*Pi*(xL - t));
+    
+    CCTK_REAL piL = -2*Pi*cos(2*Pi*(xL - t));
+    
+    /* Copy local copies back to grid functions */
+    phi[index] = phiL;
+    pi[index] = piL;
+  }
+  CCTK_ENDLOOP3(initial_sine);
+}
+
+extern "C" void initial_sine(CCTK_ARGUMENTS)
+{
+  DECLARE_CCTK_ARGUMENTS;
+  DECLARE_CCTK_PARAMETERS;
+  
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Entering initial_sine_Body");
+  }
+  
+  if (cctk_iteration % initial_sine_calc_every != initial_sine_calc_offset)
+  {
+    return;
+  }
+  
+  const char *const groups[] = {
+    "SimpleWaveODE::evolved_group",
+    "grid::coordinates",
+    "SimpleWaveODE::ode_group"};
+  GenericFD_AssertGroupStorage(cctkGH, "initial_sine", 3, groups);
+  
+  
+  GenericFD_LoopOverEverything(cctkGH, initial_sine_Body);
+  
+  if (verbose > 1)
+  {
+    CCTK_VInfo(CCTK_THORNSTRING,"Leaving initial_sine_Body");
+  }
+}
diff --git a/Examples/SimpleWaveODE/src/make.code.defn b/Examples/SimpleWaveODE/src/make.code.defn
new file mode 100644
index 0000000..3332924
--- /dev/null
+++ b/Examples/SimpleWaveODE/src/make.code.defn
@@ -0,0 +1,3 @@
+# File produced by Kranc
+
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc initial_sine.cc calc_rhs.cc Boundaries.cc 
diff --git a/Examples/SimpleWaveOpenCL/cakernel.ccl b/Examples/SimpleWaveOpenCL/cakernel.ccl
deleted file mode 100644
index 32dc04a..0000000
--- a/Examples/SimpleWaveOpenCL/cakernel.ccl
+++ /dev/null
@@ -1 +0,0 @@
-KrancThorn`Private`cakernel$438
\ No newline at end of file
diff --git a/Examples/SimpleWaveOpenCL/schedule.ccl b/Examples/SimpleWaveOpenCL/schedule.ccl
index 13a096e..ec20325 100644
--- a/Examples/SimpleWaveOpenCL/schedule.ccl
+++ b/Examples/SimpleWaveOpenCL/schedule.ccl
@@ -33,12 +33,6 @@ schedule SimpleWaveOpenCL_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule SimpleWaveOpenCL_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule SimpleWaveOpenCL_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
@@ -48,17 +42,20 @@ schedule SimpleWaveOpenCL_RegisterSymmetries in SymmetryRegister
 schedule initial_sine AT INITIAL
 {
   LANG: C
-  # TAGS: OpenCL=1
-  READS:    grid::coordinates
-  WRITES:   SimpleWaveOpenCL::evolved_group
+  TAGS: Device=1
+  READS:    grid::x
+  WRITES:   SimpleWaveOpenCL::phi
+  WRITES:   SimpleWaveOpenCL::pi
 } "initial_sine"
 
 schedule calc_rhs in MoL_CalcRHS
 {
   LANG: C
-  # TAGS: OpenCL=1
-  READS:    SimpleWaveOpenCL::evolved_group
-  WRITES:   SimpleWaveOpenCL::evolved_grouprhs
+  TAGS: Device=1
+  READS:    SimpleWaveOpenCL::phi
+  READS:    SimpleWaveOpenCL::pi
+  WRITES:   SimpleWaveOpenCL::phirhs
+  WRITES:   SimpleWaveOpenCL::pirhs
 } "calc_rhs"
 
 schedule SimpleWaveOpenCL_SelectBoundConds in MoL_PostStep
@@ -74,6 +71,12 @@ schedule SimpleWaveOpenCL_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
+schedule SimpleWaveOpenCL_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
 schedule group ApplyBCs as SimpleWaveOpenCL_ApplyBCs in MoL_PostStep after SimpleWaveOpenCL_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/SimpleWaveOpenCL/src/Differencing.h b/Examples/SimpleWaveOpenCL/src/Differencing.h
index 476bbe1..7d48129 100644
--- a/Examples/SimpleWaveOpenCL/src/Differencing.h
+++ b/Examples/SimpleWaveOpenCL/src/Differencing.h
@@ -1,4 +1,4 @@
-static char const * const differencing =
+static char const *const differencing =
 "#ifndef KRANC_DIFF_FUNCTIONS\n"
 "#  define PDstandard2nd1(u) ((-KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1o2dx)\n"
 "#else\n"
diff --git a/Examples/SimpleWaveOpenCL/src/calc_rhs.cc b/Examples/SimpleWaveOpenCL/src/calc_rhs.cc
index f463547..0344c0d 100644
--- a/Examples/SimpleWaveOpenCL/src/calc_rhs.cc
+++ b/Examples/SimpleWaveOpenCL/src/calc_rhs.cc
@@ -18,10 +18,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void calc_rhs_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,7 +40,7 @@ static void calc_rhs_Body(cGH const * restrict const cctkGH, int const dir, int
   DECLARE_CCTK_ARGUMENTS;
   DECLARE_CCTK_PARAMETERS;
   
-  char const * const source =
+  char const *const source =
   "\n"
   "/* Include user-supplied include files */\n"
   "\n"
@@ -86,9 +86,9 @@ static void calc_rhs_Body(cGH const * restrict const cctkGH, int const dir, int
   "\n"
   "/* Loop over the grid points */\n"
   "#pragma omp parallel\n"
-  "CCTK_LOOP3 (calc_rhs,\n"
+  "CCTK_LOOP3(calc_rhs,\n"
   "  i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],\n"
-  "  cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])\n"
+  "  cctk_ash[0],cctk_ash[1],cctk_ash[2])\n"
   "{\n"
   "  ptrdiff_t const index = di*i + dj*j + dk*k;\n"
   "  \n"
@@ -112,20 +112,24 @@ static void calc_rhs_Body(cGH const * restrict const cctkGH, int const dir, int
   "    PDstandard2nd33phi;\n"
   "  \n"
   "  /* Copy local copies back to grid functions */\n"
+  "  vec_store_partial_prepare(i,lc_imin,lc_imax);\n"
   "  vec_store_nta_partial(phirhs[index],phirhsL);\n"
   "  vec_store_nta_partial(pirhs[index],pirhsL);\n"
   "}\n"
-  "CCTK_ENDLOOP3 (calc_rhs);\n"
+  "CCTK_ENDLOOP3(calc_rhs);\n"
   ""
   ;
   
-  char const * const groups[] = {"SimpleWaveOpenCL::evolved_group","SimpleWaveOpenCL::evolved_grouprhs",NULL};
+  char const *const groups[] = {
+    "SimpleWaveOpenCL::evolved_group",
+    "SimpleWaveOpenCL::evolved_grouprhs",
+    NULL};
   
-  static struct OpenCLKernel * kernel = NULL;
-  char const * const sources[] = {differencing, source, NULL};
-  OpenCLRunTime_CallKernel (cctkGH, CCTK_THORNSTRING, "calc_rhs",
-                            sources, groups, NULL, NULL, NULL, -1,
-                            imin, imax, &kernel);
+  static struct OpenCLKernel *kernel = NULL;
+  char const *const sources[] = {differencing, source, NULL};
+  OpenCLRunTime_CallKernel(cctkGH, CCTK_THORNSTRING, "calc_rhs",
+                           sources, groups, NULL, NULL, NULL, -1,
+                           imin, imax, &kernel);
   
 }
 
@@ -145,12 +149,14 @@ extern "C" void calc_rhs(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"SimpleWaveOpenCL::evolved_group","SimpleWaveOpenCL::evolved_grouprhs"};
+  const char *const groups[] = {
+    "SimpleWaveOpenCL::evolved_group",
+    "SimpleWaveOpenCL::evolved_grouprhs"};
   GenericFD_AssertGroupStorage(cctkGH, "calc_rhs", 2, groups);
   
   GenericFD_EnsureStencilFits(cctkGH, "calc_rhs", 1, 1, 1);
   
-  GenericFD_LoopOverInterior(cctkGH, &calc_rhs_Body);
+  GenericFD_LoopOverInterior(cctkGH, calc_rhs_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/SimpleWaveOpenCL/src/initial_sine.cc b/Examples/SimpleWaveOpenCL/src/initial_sine.cc
index fa553dd..b29c7b5 100644
--- a/Examples/SimpleWaveOpenCL/src/initial_sine.cc
+++ b/Examples/SimpleWaveOpenCL/src/initial_sine.cc
@@ -18,17 +18,17 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void initial_sine_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
   DECLARE_CCTK_ARGUMENTS;
   DECLARE_CCTK_PARAMETERS;
   
-  char const * const source =
+  char const *const source =
   "\n"
   "/* Include user-supplied include files */\n"
   "\n"
@@ -74,9 +74,9 @@ static void initial_sine_Body(cGH const * restrict const cctkGH, int const dir,
   "\n"
   "/* Loop over the grid points */\n"
   "#pragma omp parallel\n"
-  "CCTK_LOOP3 (initial_sine,\n"
+  "CCTK_LOOP3(initial_sine,\n"
   "  i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],\n"
-  "  cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])\n"
+  "  cctk_ash[0],cctk_ash[1],cctk_ash[2])\n"
   "{\n"
   "  ptrdiff_t const index = di*i + dj*j + dk*k;\n"
   "  \n"
@@ -90,25 +90,29 @@ static void initial_sine_Body(cGH const * restrict const cctkGH, int const dir,
   "  /* Precompute derivatives */\n"
   "  \n"
   "  /* Calculate temporaries and grid functions */\n"
-  "  CCTK_REAL phiL = Sin(2*Pi*(xL - t));\n"
+  "  CCTK_REAL phiL = sin(2*Pi*(xL - t));\n"
   "  \n"
-  "  CCTK_REAL piL = -2*Pi*Cos(2*Pi*(xL - t));\n"
+  "  CCTK_REAL piL = -2*Pi*cos(2*Pi*(xL - t));\n"
   "  \n"
   "  /* Copy local copies back to grid functions */\n"
+  "  vec_store_partial_prepare(i,lc_imin,lc_imax);\n"
   "  vec_store_nta_partial(phi[index],phiL);\n"
   "  vec_store_nta_partial(pi[index],piL);\n"
   "}\n"
-  "CCTK_ENDLOOP3 (initial_sine);\n"
+  "CCTK_ENDLOOP3(initial_sine);\n"
   ""
   ;
   
-  char const * const groups[] = {"SimpleWaveOpenCL::evolved_group","grid::coordinates",NULL};
+  char const *const groups[] = {
+    "SimpleWaveOpenCL::evolved_group",
+    "grid::coordinates",
+    NULL};
   
-  static struct OpenCLKernel * kernel = NULL;
-  char const * const sources[] = {differencing, source, NULL};
-  OpenCLRunTime_CallKernel (cctkGH, CCTK_THORNSTRING, "initial_sine",
-                            sources, groups, NULL, NULL, NULL, -1,
-                            imin, imax, &kernel);
+  static struct OpenCLKernel *kernel = NULL;
+  char const *const sources[] = {differencing, source, NULL};
+  OpenCLRunTime_CallKernel(cctkGH, CCTK_THORNSTRING, "initial_sine",
+                           sources, groups, NULL, NULL, NULL, -1,
+                           imin, imax, &kernel);
   
 }
 
@@ -128,11 +132,13 @@ extern "C" void initial_sine(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"SimpleWaveOpenCL::evolved_group","grid::coordinates"};
+  const char *const groups[] = {
+    "SimpleWaveOpenCL::evolved_group",
+    "grid::coordinates"};
   GenericFD_AssertGroupStorage(cctkGH, "initial_sine", 2, groups);
   
   
-  GenericFD_LoopOverEverything(cctkGH, &initial_sine_Body);
+  GenericFD_LoopOverEverything(cctkGH, initial_sine_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/SimpleWaveOpenCL/src/make.code.defn b/Examples/SimpleWaveOpenCL/src/make.code.defn
index 535f5d0..3332924 100644
--- a/Examples/SimpleWaveOpenCL/src/make.code.defn
+++ b/Examples/SimpleWaveOpenCL/src/make.code.defn
@@ -1,3 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc initial_sine.cc calc_rhs.cc Boundaries.cc 
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc initial_sine.cc calc_rhs.cc Boundaries.cc 
diff --git a/Examples/Wave/param.ccl b/Examples/Wave/param.ccl
index ae83072..ff10447 100644
--- a/Examples/Wave/param.ccl
+++ b/Examples/Wave/param.ccl
@@ -77,12 +77,6 @@ CCTK_REAL diss "diss"
 } 0
 
 restricted:
-CCTK_REAL hlleAlpha "hlleAlpha"
-{
-  "*:*" :: ""
-} 0
-
-restricted:
 CCTK_INT fdOrder "fdOrder"
 {
   *:* :: ""
diff --git a/Examples/Wave/schedule.ccl b/Examples/Wave/schedule.ccl
index e9e28e0..719d86f 100644
--- a/Examples/Wave/schedule.ccl
+++ b/Examples/Wave/schedule.ccl
@@ -72,12 +72,6 @@ schedule Wave_Startup at STARTUP
   OPTIONS: meta
 } "create banner"
 
-schedule Wave_RegisterVars in MoL_Register
-{
-  LANG: C
-  OPTIONS: meta
-} "Register Variables for MoL"
-
 schedule Wave_RegisterSymmetries in SymmetryRegister
 {
   LANG: C
@@ -90,6 +84,11 @@ if (CCTK_EQUALS(initial_data, "sine"))
   schedule wave_exact_sine AT INITIAL before import_exact before import_exact
   {
     LANG: C
+    READS:    grid::x
+    READS:    grid::y
+    READS:    grid::z
+    WRITES:   Wave::phiExact
+    WRITES:   Wave::piExact
   } "wave_exact_sine"
 }
 
@@ -99,6 +98,11 @@ if (CCTK_EQUALS(initial_data, "sine"))
   schedule wave_exact_sine AT POSTSTEP before calc_errors before import_exact
   {
     LANG: C
+    READS:    grid::x
+    READS:    grid::y
+    READS:    grid::z
+    WRITES:   Wave::phiExact
+    WRITES:   Wave::piExact
   } "wave_exact_sine"
 }
 
@@ -108,6 +112,9 @@ if (CCTK_EQUALS(initial_data, "gaussian"))
   schedule wave_exact_gaussian AT INITIAL before import_exact before import_exact
   {
     LANG: C
+    READS:    grid::r
+    WRITES:   Wave::phiExact
+    WRITES:   Wave::piExact
   } "wave_exact_gaussian"
 }
 
@@ -117,28 +124,52 @@ if (CCTK_EQUALS(initial_data, "gaussian"))
   schedule wave_exact_gaussian AT POSTSTEP before calc_errors before import_exact
   {
     LANG: C
+    READS:    grid::r
+    WRITES:   Wave::phiExact
+    WRITES:   Wave::piExact
   } "wave_exact_gaussian"
 }
 
 schedule wave_import_exact at INITIAL as import_exact
 {
   LANG: C
+  READS:    Wave::phiExact
+  READS:    Wave::piExact
+  WRITES:   Wave::phi
+  WRITES:   Wave::pi
 } "wave_import_exact"
 
 schedule wave_evolve in MoL_CalcRHS as evolve
 {
   LANG: C
+  READS:    Wave::phi
+  READS:    Wave::pi
+  WRITES:   Wave::phirhs
+  WRITES:   Wave::pirhs
 } "wave_evolve"
 
 schedule wave_calc_errors at ANALYSIS as calc_errors
 {
   LANG: C
+  READS:    Wave::phi
+  READS:    Wave::phiExact
+  READS:    Wave::pi
+  READS:    Wave::piExact
+  WRITES:   Wave::phiError
+  WRITES:   Wave::piError
 } "wave_calc_errors"
 
 schedule wave_calc_norm at ANALYSIS as calc_norm
 {
   LANG: C
   SYNC: norms
+  READS:    Wave::phi
+  READS:    Wave::phiError
+  READS:    Wave::pi
+  READS:    Wave::piError
+  WRITES:   Wave::EL2
+  WRITES:   Wave::VDP
+  WRITES:   Wave::VL2
 } "wave_calc_norm"
 
 
@@ -147,6 +178,14 @@ if (CCTK_EQUALS(boundary_condition, "radiative"))
   schedule wave_boundary in MoL_RHSBoundaries
   {
     LANG: C
+    READS:    Wave::phi
+    READS:    Wave::pi
+    READS:    grid::r
+    READS:    grid::x
+    READS:    grid::y
+    READS:    grid::z
+    WRITES:   Wave::phirhs
+    WRITES:   Wave::pirhs
   } "wave_boundary"
 }
 
@@ -163,6 +202,12 @@ schedule Wave_CheckBoundaries at BASEGRID
   OPTIONS: meta
 } "check boundaries treatment"
 
+schedule Wave_RegisterVars in MoL_Register
+{
+  LANG: C
+  OPTIONS: meta
+} "Register Variables for MoL"
+
 schedule group ApplyBCs as Wave_ApplyBCs in MoL_PostStep after Wave_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/Wave/src/Differencing.h b/Examples/Wave/src/Differencing.h
index c809b72..28eb5d5 100644
--- a/Examples/Wave/src/Differencing.h
+++ b/Examples/Wave/src/Differencing.h
@@ -323,26 +323,26 @@ static CCTK_REAL PDonesided2nd3_impl(CCTK_REAL const* restrict const u, CCTK_REA
 #endif
 
 #ifndef KRANC_DIFF_FUNCTIONS
-#  define DissfdOrder2(u) (-(p1odxdydz*diss*((6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1)) + KRANC_GFOFFSET3D(u,0,0,-2) + KRANC_GFOFFSET3D(u,0,0,2))*INV(dxi)*INV(dyi) + ((6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0)) + KRANC_GFOFFSET3D(u,0,-2,0) + KRANC_GFOFFSET3D(u,0,2,0))*INV(dxi) + (6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0)) + KRANC_GFOFFSET3D(u,-2,0,0) + KRANC_GFOFFSET3D(u,2,0,0))*INV(dyi))*INV(dzi))))
+#  define DissfdOrder2(u) (-(p1odxdydz*diss*((6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1)) + KRANC_GFOFFSET3D(u,0,0,-2) + KRANC_GFOFFSET3D(u,0,0,2))*INV(dxi*dyi) + ((6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0)) + KRANC_GFOFFSET3D(u,0,-2,0) + KRANC_GFOFFSET3D(u,0,2,0))*INV(dxi) + (6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0)) + KRANC_GFOFFSET3D(u,-2,0,0) + KRANC_GFOFFSET3D(u,2,0,0))*INV(dyi))*INV(dzi))))
 #else
 #  define DissfdOrder2(u) (DissfdOrder2_impl(u,p1odxdydz,cdj,cdk))
 static CCTK_REAL DissfdOrder2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odxdydz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
 static CCTK_REAL DissfdOrder2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odxdydz, ptrdiff_t const cdj, ptrdiff_t const cdk)
 {
   ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return -(p1odxdydz*diss*((6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1)) + KRANC_GFOFFSET3D(u,0,0,-2) + KRANC_GFOFFSET3D(u,0,0,2))*INV(dxi)*INV(dyi) + ((6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0)) + KRANC_GFOFFSET3D(u,0,-2,0) + KRANC_GFOFFSET3D(u,0,2,0))*INV(dxi) + (6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0)) + KRANC_GFOFFSET3D(u,-2,0,0) + KRANC_GFOFFSET3D(u,2,0,0))*INV(dyi))*INV(dzi)));
+  return -(p1odxdydz*diss*((6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1)) + KRANC_GFOFFSET3D(u,0,0,-2) + KRANC_GFOFFSET3D(u,0,0,2))*INV(dxi*dyi) + ((6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0)) + KRANC_GFOFFSET3D(u,0,-2,0) + KRANC_GFOFFSET3D(u,0,2,0))*INV(dxi) + (6*KRANC_GFOFFSET3D(u,0,0,0) - 4*(KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0)) + KRANC_GFOFFSET3D(u,-2,0,0) + KRANC_GFOFFSET3D(u,2,0,0))*INV(dyi))*INV(dzi)));
 }
 #endif
 
 #ifndef KRANC_DIFF_FUNCTIONS
-#  define DissfdOrder4(u) (p1odxdydz*diss*((-20*KRANC_GFOFFSET3D(u,0,0,0) + 15*(KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1)) - 6*(KRANC_GFOFFSET3D(u,0,0,-2) + KRANC_GFOFFSET3D(u,0,0,2)) + KRANC_GFOFFSET3D(u,0,0,-3) + KRANC_GFOFFSET3D(u,0,0,3))*INV(dxi)*INV(dyi) + ((15*(KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0)) - 6*(KRANC_GFOFFSET3D(u,0,-2,0) + KRANC_GFOFFSET3D(u,0,2,0)) + KRANC_GFOFFSET3D(u,0,-3,0) + KRANC_GFOFFSET3D(u,0,3,0))*INV(dxi) + (15*(KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0)) - 6*(KRANC_GFOFFSET3D(u,-2,0,0) + KRANC_GFOFFSET3D(u,2,0,0)) + KRANC_GFOFFSET3D(u,-3,0,0) + KRANC_GFOFFSET3D(u,3,0,0))*INV(dyi) - 20*KRANC_GFOFFSET3D(u,0,0,0)*(INV(dxi) + INV(dyi)))*INV(dzi)))
+#  define DissfdOrder4(u) (p1odxdydz*diss*((-20*KRANC_GFOFFSET3D(u,0,0,0) + 15*(KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1)) - 6*(KRANC_GFOFFSET3D(u,0,0,-2) + KRANC_GFOFFSET3D(u,0,0,2)) + KRANC_GFOFFSET3D(u,0,0,-3) + KRANC_GFOFFSET3D(u,0,0,3))*INV(dxi*dyi) + ((15*(KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0)) - 6*(KRANC_GFOFFSET3D(u,0,-2,0) + KRANC_GFOFFSET3D(u,0,2,0)) + KRANC_GFOFFSET3D(u,0,-3,0) + KRANC_GFOFFSET3D(u,0,3,0))*INV(dxi) + (15*(KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0)) - 6*(KRANC_GFOFFSET3D(u,-2,0,0) + KRANC_GFOFFSET3D(u,2,0,0)) + KRANC_GFOFFSET3D(u,-3,0,0) + KRANC_GFOFFSET3D(u,3,0,0))*INV(dyi) - 20*KRANC_GFOFFSET3D(u,0,0,0)*(INV(dxi) + INV(dyi)))*INV(dzi)))
 #else
 #  define DissfdOrder4(u) (DissfdOrder4_impl(u,p1odxdydz,cdj,cdk))
 static CCTK_REAL DissfdOrder4_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odxdydz, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
 static CCTK_REAL DissfdOrder4_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1odxdydz, ptrdiff_t const cdj, ptrdiff_t const cdk)
 {
   ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return p1odxdydz*diss*((-20*KRANC_GFOFFSET3D(u,0,0,0) + 15*(KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1)) - 6*(KRANC_GFOFFSET3D(u,0,0,-2) + KRANC_GFOFFSET3D(u,0,0,2)) + KRANC_GFOFFSET3D(u,0,0,-3) + KRANC_GFOFFSET3D(u,0,0,3))*INV(dxi)*INV(dyi) + ((15*(KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0)) - 6*(KRANC_GFOFFSET3D(u,0,-2,0) + KRANC_GFOFFSET3D(u,0,2,0)) + KRANC_GFOFFSET3D(u,0,-3,0) + KRANC_GFOFFSET3D(u,0,3,0))*INV(dxi) + (15*(KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0)) - 6*(KRANC_GFOFFSET3D(u,-2,0,0) + KRANC_GFOFFSET3D(u,2,0,0)) + KRANC_GFOFFSET3D(u,-3,0,0) + KRANC_GFOFFSET3D(u,3,0,0))*INV(dyi) - 20*KRANC_GFOFFSET3D(u,0,0,0)*(INV(dxi) + INV(dyi)))*INV(dzi));
+  return p1odxdydz*diss*((-20*KRANC_GFOFFSET3D(u,0,0,0) + 15*(KRANC_GFOFFSET3D(u,0,0,-1) + KRANC_GFOFFSET3D(u,0,0,1)) - 6*(KRANC_GFOFFSET3D(u,0,0,-2) + KRANC_GFOFFSET3D(u,0,0,2)) + KRANC_GFOFFSET3D(u,0,0,-3) + KRANC_GFOFFSET3D(u,0,0,3))*INV(dxi*dyi) + ((15*(KRANC_GFOFFSET3D(u,0,-1,0) + KRANC_GFOFFSET3D(u,0,1,0)) - 6*(KRANC_GFOFFSET3D(u,0,-2,0) + KRANC_GFOFFSET3D(u,0,2,0)) + KRANC_GFOFFSET3D(u,0,-3,0) + KRANC_GFOFFSET3D(u,0,3,0))*INV(dxi) + (15*(KRANC_GFOFFSET3D(u,-1,0,0) + KRANC_GFOFFSET3D(u,1,0,0)) - 6*(KRANC_GFOFFSET3D(u,-2,0,0) + KRANC_GFOFFSET3D(u,2,0,0)) + KRANC_GFOFFSET3D(u,-3,0,0) + KRANC_GFOFFSET3D(u,3,0,0))*INV(dyi) - 20*KRANC_GFOFFSET3D(u,0,0,0)*(INV(dxi) + INV(dyi)))*INV(dzi));
 }
 #endif
 
@@ -526,111 +526,3 @@ static CCTK_REAL PDplus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const
 }
 #endif
 
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffPlus1(u) ((-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1o1)
-#else
-#  define DiffPlus1(u) (DiffPlus1_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffPlus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffPlus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,1,0,0))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffPlus2(u) ((-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1o1)
-#else
-#  define DiffPlus2(u) (DiffPlus2_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffPlus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffPlus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,1,0))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffPlus3(u) ((-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,1))*p1o1)
-#else
-#  define DiffPlus3(u) (DiffPlus3_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffPlus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffPlus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (-KRANC_GFOFFSET3D(u,0,0,0) + KRANC_GFOFFSET3D(u,0,0,1))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffMinus1(u) ((KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,-1,0,0))*p1o1)
-#else
-#  define DiffMinus1(u) (DiffMinus1_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffMinus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffMinus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,-1,0,0))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffMinus2(u) ((KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,0,-1,0))*p1o1)
-#else
-#  define DiffMinus2(u) (DiffMinus2_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffMinus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffMinus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,0,-1,0))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define DiffMinus3(u) ((KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,0,0,-1))*p1o1)
-#else
-#  define DiffMinus3(u) (DiffMinus3_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL DiffMinus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL DiffMinus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return (KRANC_GFOFFSET3D(u,0,0,0) - KRANC_GFOFFSET3D(u,0,0,-1))*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define ShiftMinus1(u) (KRANC_GFOFFSET3D(u,-1,0,0)*p1o1)
-#else
-#  define ShiftMinus1(u) (ShiftMinus1_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL ShiftMinus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL ShiftMinus1_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return KRANC_GFOFFSET3D(u,-1,0,0)*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define ShiftMinus2(u) (KRANC_GFOFFSET3D(u,0,-1,0)*p1o1)
-#else
-#  define ShiftMinus2(u) (ShiftMinus2_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL ShiftMinus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL ShiftMinus2_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return KRANC_GFOFFSET3D(u,0,-1,0)*p1o1;
-}
-#endif
-
-#ifndef KRANC_DIFF_FUNCTIONS
-#  define ShiftMinus3(u) (KRANC_GFOFFSET3D(u,0,0,-1)*p1o1)
-#else
-#  define ShiftMinus3(u) (ShiftMinus3_impl(u,p1o1,cdj,cdk))
-static CCTK_REAL ShiftMinus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk) CCTK_ATTRIBUTE_NOINLINE CCTK_ATTRIBUTE_UNUSED;
-static CCTK_REAL ShiftMinus3_impl(CCTK_REAL const* restrict const u, CCTK_REAL const p1o1, ptrdiff_t const cdj, ptrdiff_t const cdk)
-{
-  ptrdiff_t const cdi=sizeof(CCTK_REAL);
-  return KRANC_GFOFFSET3D(u,0,0,-1)*p1o1;
-}
-#endif
-
diff --git a/Examples/Wave/src/make.code.defn b/Examples/Wave/src/make.code.defn
index 4dcd739..48fb287 100644
--- a/Examples/Wave/src/make.code.defn
+++ b/Examples/Wave/src/make.code.defn
@@ -1,3 +1,3 @@
 # File produced by Kranc
 
-SRCS = Startup.cc RegisterMoL.cc RegisterSymmetries.cc wave_exact_sine.cc wave_exact_gaussian.cc wave_import_exact.cc wave_evolve.cc wave_calc_errors.cc wave_calc_norm.cc wave_boundary.cc Boundaries.cc 
+SRCS = Startup.cc RegisterSymmetries.cc RegisterMoL.cc wave_exact_sine.cc wave_exact_gaussian.cc wave_import_exact.cc wave_evolve.cc wave_calc_errors.cc wave_calc_norm.cc wave_boundary.cc Boundaries.cc 
diff --git a/Examples/Wave/src/wave_boundary.cc b/Examples/Wave/src/wave_boundary.cc
index 2ec1e2c..3ff86ec 100644
--- a/Examples/Wave/src/wave_boundary.cc
+++ b/Examples/Wave/src/wave_boundary.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void wave_boundary_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void wave_boundary_Body(cGH const * restrict const cctkGH, int const dir,
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -69,25 +67,24 @@ static void wave_boundary_Body(cGH const * restrict const cctkGH, int const dir,
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
   CCTK_REAL const p1o4dx2 = 0.25*INV(SQR(dx));
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
   CCTK_REAL const p1o4dy2 = 0.25*INV(SQR(dy));
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1o4dz2 = 0.25*INV(SQR(dz));
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1odxdydz = INV(dx)*INV(dy)*INV(dz);
+  CCTK_REAL const p1odxdydz = INV(dx*dy*dz);
   CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const p1odz = INV(dz);
@@ -109,9 +106,9 @@ static void wave_boundary_Body(cGH const * restrict const cctkGH, int const dir,
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (wave_boundary,
+  CCTK_LOOP3(wave_boundary,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -145,11 +142,11 @@ static void wave_boundary_Body(cGH const * restrict const cctkGH, int const dir,
     
     CCTK_REAL norm3 = -(zL*INV(rL));
     
-    ptrdiff_t dir1 = Sign(norm1);
+    ptrdiff_t dir1 = isgn(norm1);
     
-    ptrdiff_t dir2 = Sign(norm2);
+    ptrdiff_t dir2 = isgn(norm2);
     
-    ptrdiff_t dir3 = Sign(norm3);
+    ptrdiff_t dir3 = isgn(norm3);
     
     CCTK_REAL phirhsL = PDonesided2nd1(&phi[index])*norm1 + 
       PDonesided2nd2(&phi[index])*norm2 + 
@@ -163,7 +160,7 @@ static void wave_boundary_Body(cGH const * restrict const cctkGH, int const dir,
     phirhs[index] = phirhsL;
     pirhs[index] = pirhsL;
   }
-  CCTK_ENDLOOP3 (wave_boundary);
+  CCTK_ENDLOOP3(wave_boundary);
 }
 
 extern "C" void wave_boundary(CCTK_ARGUMENTS)
@@ -182,7 +179,10 @@ extern "C" void wave_boundary(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Wave::evolved","Wave::evolvedrhs","grid::coordinates"};
+  const char *const groups[] = {
+    "Wave::evolved",
+    "Wave::evolvedrhs",
+    "grid::coordinates"};
   GenericFD_AssertGroupStorage(cctkGH, "wave_boundary", 3, groups);
   
   switch(fdOrder)
@@ -196,7 +196,7 @@ extern "C" void wave_boundary(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverBoundary(cctkGH, &wave_boundary_Body);
+  GenericFD_LoopOverBoundary(cctkGH, wave_boundary_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Wave/src/wave_calc_errors.cc b/Examples/Wave/src/wave_calc_errors.cc
index a133c1a..1547953 100644
--- a/Examples/Wave/src/wave_calc_errors.cc
+++ b/Examples/Wave/src/wave_calc_errors.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void wave_calc_errors_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void wave_calc_errors_Body(cGH const * restrict const cctkGH, int const d
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -57,25 +55,24 @@ static void wave_calc_errors_Body(cGH const * restrict const cctkGH, int const d
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
   CCTK_REAL const p1o4dx2 = 0.25*INV(SQR(dx));
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
   CCTK_REAL const p1o4dy2 = 0.25*INV(SQR(dy));
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1o4dz2 = 0.25*INV(SQR(dz));
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1odxdydz = INV(dx)*INV(dy)*INV(dz);
+  CCTK_REAL const p1odxdydz = INV(dx*dy*dz);
   CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const p1odz = INV(dz);
@@ -97,9 +94,9 @@ static void wave_calc_errors_Body(cGH const * restrict const cctkGH, int const d
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (wave_calc_errors,
+  CCTK_LOOP3(wave_calc_errors,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -133,7 +130,7 @@ static void wave_calc_errors_Body(cGH const * restrict const cctkGH, int const d
     phiError[index] = phiErrorL;
     piError[index] = piErrorL;
   }
-  CCTK_ENDLOOP3 (wave_calc_errors);
+  CCTK_ENDLOOP3(wave_calc_errors);
 }
 
 extern "C" void wave_calc_errors(CCTK_ARGUMENTS)
@@ -152,7 +149,10 @@ extern "C" void wave_calc_errors(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Wave::errors","Wave::evolved","Wave::exact"};
+  const char *const groups[] = {
+    "Wave::errors",
+    "Wave::evolved",
+    "Wave::exact"};
   GenericFD_AssertGroupStorage(cctkGH, "wave_calc_errors", 3, groups);
   
   switch(fdOrder)
@@ -164,7 +164,7 @@ extern "C" void wave_calc_errors(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverEverything(cctkGH, &wave_calc_errors_Body);
+  GenericFD_LoopOverEverything(cctkGH, wave_calc_errors_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Wave/src/wave_calc_norm.cc b/Examples/Wave/src/wave_calc_norm.cc
index 7e15d73..58d8de3 100644
--- a/Examples/Wave/src/wave_calc_norm.cc
+++ b/Examples/Wave/src/wave_calc_norm.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void wave_calc_norm_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void wave_calc_norm_Body(cGH const * restrict const cctkGH, int const dir
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -69,25 +67,24 @@ static void wave_calc_norm_Body(cGH const * restrict const cctkGH, int const dir
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
   CCTK_REAL const p1o4dx2 = 0.25*INV(SQR(dx));
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
   CCTK_REAL const p1o4dy2 = 0.25*INV(SQR(dy));
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1o4dz2 = 0.25*INV(SQR(dz));
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1odxdydz = INV(dx)*INV(dy)*INV(dz);
+  CCTK_REAL const p1odxdydz = INV(dx*dy*dz);
   CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const p1odz = INV(dz);
@@ -109,9 +106,9 @@ static void wave_calc_norm_Body(cGH const * restrict const cctkGH, int const dir
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (wave_calc_norm,
+  CCTK_LOOP3(wave_calc_norm,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -164,7 +161,7 @@ static void wave_calc_norm_Body(cGH const * restrict const cctkGH, int const dir
     VDP[index] = VDPL;
     VL2[index] = VL2L;
   }
-  CCTK_ENDLOOP3 (wave_calc_norm);
+  CCTK_ENDLOOP3(wave_calc_norm);
 }
 
 extern "C" void wave_calc_norm(CCTK_ARGUMENTS)
@@ -183,7 +180,10 @@ extern "C" void wave_calc_norm(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Wave::errors","Wave::evolved","Wave::norms"};
+  const char *const groups[] = {
+    "Wave::errors",
+    "Wave::evolved",
+    "Wave::norms"};
   GenericFD_AssertGroupStorage(cctkGH, "wave_calc_norm", 3, groups);
   
   switch(fdOrder)
@@ -197,7 +197,7 @@ extern "C" void wave_calc_norm(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverInterior(cctkGH, &wave_calc_norm_Body);
+  GenericFD_LoopOverInterior(cctkGH, wave_calc_norm_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Wave/src/wave_evolve.cc b/Examples/Wave/src/wave_evolve.cc
index 5c6314d..5cee251 100644
--- a/Examples/Wave/src/wave_evolve.cc
+++ b/Examples/Wave/src/wave_evolve.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void wave_evolve_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -40,8 +40,6 @@ static void wave_evolve_Body(cGH const * restrict const cctkGH, int const dir, i
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -69,25 +67,24 @@ static void wave_evolve_Body(cGH const * restrict const cctkGH, int const dir, i
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
   CCTK_REAL const p1o4dx2 = 0.25*INV(SQR(dx));
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
   CCTK_REAL const p1o4dy2 = 0.25*INV(SQR(dy));
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1o4dz2 = 0.25*INV(SQR(dz));
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1odxdydz = INV(dx)*INV(dy)*INV(dz);
+  CCTK_REAL const p1odxdydz = INV(dx*dy*dz);
   CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const p1odz = INV(dz);
@@ -109,9 +106,9 @@ static void wave_evolve_Body(cGH const * restrict const cctkGH, int const dir, i
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (wave_evolve,
+  CCTK_LOOP3(wave_evolve,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -153,7 +150,7 @@ static void wave_evolve_Body(cGH const * restrict const cctkGH, int const dir, i
     phirhs[index] = phirhsL;
     pirhs[index] = pirhsL;
   }
-  CCTK_ENDLOOP3 (wave_evolve);
+  CCTK_ENDLOOP3(wave_evolve);
 }
 
 extern "C" void wave_evolve(CCTK_ARGUMENTS)
@@ -172,7 +169,9 @@ extern "C" void wave_evolve(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Wave::evolved","Wave::evolvedrhs"};
+  const char *const groups[] = {
+    "Wave::evolved",
+    "Wave::evolvedrhs"};
   GenericFD_AssertGroupStorage(cctkGH, "wave_evolve", 2, groups);
   
   switch(fdOrder)
@@ -186,7 +185,7 @@ extern "C" void wave_evolve(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverInterior(cctkGH, &wave_evolve_Body);
+  GenericFD_LoopOverInterior(cctkGH, wave_evolve_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Wave/src/wave_exact_gaussian.cc b/Examples/Wave/src/wave_exact_gaussian.cc
index ed37143..82c1bc7 100644
--- a/Examples/Wave/src/wave_exact_gaussian.cc
+++ b/Examples/Wave/src/wave_exact_gaussian.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void wave_exact_gaussian_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void wave_exact_gaussian_Body(cGH const * restrict const cctkGH, int cons
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -57,25 +55,24 @@ static void wave_exact_gaussian_Body(cGH const * restrict const cctkGH, int cons
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
   CCTK_REAL const p1o4dx2 = 0.25*INV(SQR(dx));
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
   CCTK_REAL const p1o4dy2 = 0.25*INV(SQR(dy));
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1o4dz2 = 0.25*INV(SQR(dz));
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1odxdydz = INV(dx)*INV(dy)*INV(dz);
+  CCTK_REAL const p1odxdydz = INV(dx*dy*dz);
   CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const p1odz = INV(dz);
@@ -97,9 +94,9 @@ static void wave_exact_gaussian_Body(cGH const * restrict const cctkGH, int cons
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (wave_exact_gaussian,
+  CCTK_LOOP3(wave_exact_gaussian,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -124,26 +121,26 @@ static void wave_exact_gaussian_Body(cGH const * restrict const cctkGH, int cons
     /* Calculate temporaries and grid functions */
     CCTK_REAL rEps = pow(1.e-24 + QAD(rL),0.25);
     
-    CCTK_REAL phiExactL = (-(CUB(-rL + cctk_time + 
-      ToReal(t0))*exp(-(INV(SQR(ToReal(nSigma)))*SQR(-rL + cctk_time + 
-      ToReal(t0))))) + CUB(rL + cctk_time + 
-      ToReal(t0))*exp(-(INV(SQR(ToReal(nSigma)))*SQR(rL + cctk_time + 
+    CCTK_REAL phiExactL = (-(CUB(-rL + t + 
+      ToReal(t0))*exp(-(INV(SQR(ToReal(nSigma)))*SQR(-rL + t + 
+      ToReal(t0))))) + CUB(rL + t + 
+      ToReal(t0))*exp(-(INV(SQR(ToReal(nSigma)))*SQR(rL + t + 
       ToReal(t0)))))*INV(rEps);
     
     CCTK_REAL piExactL = 
       INV(rEps)*(INV(SQR(ToReal(nSigma)))*(2*exp(-(INV(SQR(ToReal(nSigma)))*SQR(-rL 
-      + cctk_time + ToReal(t0))))*QAD(-rL + cctk_time + ToReal(t0)) - 
-      2*exp(-(INV(SQR(ToReal(nSigma)))*SQR(rL + cctk_time + ToReal(t0))))*QAD(rL 
-      + cctk_time + ToReal(t0))) - 3*exp(-(INV(SQR(ToReal(nSigma)))*SQR(-rL + cctk_time + 
-      ToReal(t0))))*SQR(-rL + cctk_time + ToReal(t0)) + 
-      3*exp(-(INV(SQR(ToReal(nSigma)))*SQR(rL + cctk_time + ToReal(t0))))*SQR(rL 
-      + cctk_time + ToReal(t0)));
+      + t + ToReal(t0))))*QAD(-rL + t + ToReal(t0)) - 
+      2*exp(-(INV(SQR(ToReal(nSigma)))*SQR(rL + t + ToReal(t0))))*QAD(rL 
+      + t + ToReal(t0))) - 3*exp(-(INV(SQR(ToReal(nSigma)))*SQR(-rL + t + 
+      ToReal(t0))))*SQR(-rL + t + ToReal(t0)) + 
+      3*exp(-(INV(SQR(ToReal(nSigma)))*SQR(rL + t + ToReal(t0))))*SQR(rL 
+      + t + ToReal(t0)));
     
     /* Copy local copies back to grid functions */
     phiExact[index] = phiExactL;
     piExact[index] = piExactL;
   }
-  CCTK_ENDLOOP3 (wave_exact_gaussian);
+  CCTK_ENDLOOP3(wave_exact_gaussian);
 }
 
 extern "C" void wave_exact_gaussian(CCTK_ARGUMENTS)
@@ -162,7 +159,9 @@ extern "C" void wave_exact_gaussian(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Wave::exact","grid::coordinates"};
+  const char *const groups[] = {
+    "Wave::exact",
+    "grid::coordinates"};
   GenericFD_AssertGroupStorage(cctkGH, "wave_exact_gaussian", 2, groups);
   
   switch(fdOrder)
@@ -174,7 +173,7 @@ extern "C" void wave_exact_gaussian(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverEverything(cctkGH, &wave_exact_gaussian_Body);
+  GenericFD_LoopOverEverything(cctkGH, wave_exact_gaussian_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Wave/src/wave_exact_sine.cc b/Examples/Wave/src/wave_exact_sine.cc
index 78c4251..3f6dc52 100644
--- a/Examples/Wave/src/wave_exact_sine.cc
+++ b/Examples/Wave/src/wave_exact_sine.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void wave_exact_sine_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void wave_exact_sine_Body(cGH const * restrict const cctkGH, int const di
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -57,25 +55,24 @@ static void wave_exact_sine_Body(cGH const * restrict const cctkGH, int const di
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
   CCTK_REAL const p1o4dx2 = 0.25*INV(SQR(dx));
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
   CCTK_REAL const p1o4dy2 = 0.25*INV(SQR(dy));
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1o4dz2 = 0.25*INV(SQR(dz));
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1odxdydz = INV(dx)*INV(dy)*INV(dz);
+  CCTK_REAL const p1odxdydz = INV(dx*dy*dz);
   CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const p1odz = INV(dz);
@@ -97,9 +94,9 @@ static void wave_exact_sine_Body(cGH const * restrict const cctkGH, int const di
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (wave_exact_sine,
+  CCTK_LOOP3(wave_exact_sine,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -127,12 +124,12 @@ static void wave_exact_sine_Body(cGH const * restrict const cctkGH, int const di
     CCTK_REAL piconst = 3.1415926535897932385;
     
     CCTK_REAL phiExactL = 
-      Sin(2*piconst*INV(ToReal(periodicity))*(-(cctk_time*sqrt(SQR(ToReal(n1)) + 
+      sin(2*piconst*INV(ToReal(periodicity))*(-(t*sqrt(SQR(ToReal(n1)) + 
       SQR(ToReal(n2)) + SQR(ToReal(n3)))) + xL*ToReal(n1) + yL*ToReal(n2) 
       + zL*ToReal(n3)))*ToReal(amplitude);
     
     CCTK_REAL piExactL = 
-      -2*piconst*Cos(2*piconst*INV(ToReal(periodicity))*(-(cctk_time*sqrt(SQR(ToReal(n1)) 
+      -2*piconst*cos(2*piconst*INV(ToReal(periodicity))*(-(t*sqrt(SQR(ToReal(n1)) 
       + SQR(ToReal(n2)) + SQR(ToReal(n3)))) + xL*ToReal(n1) + 
       yL*ToReal(n2) + 
       zL*ToReal(n3)))*INV(ToReal(periodicity))*sqrt(SQR(ToReal(n1)) + 
@@ -142,7 +139,7 @@ static void wave_exact_sine_Body(cGH const * restrict const cctkGH, int const di
     phiExact[index] = phiExactL;
     piExact[index] = piExactL;
   }
-  CCTK_ENDLOOP3 (wave_exact_sine);
+  CCTK_ENDLOOP3(wave_exact_sine);
 }
 
 extern "C" void wave_exact_sine(CCTK_ARGUMENTS)
@@ -161,7 +158,9 @@ extern "C" void wave_exact_sine(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Wave::exact","grid::coordinates"};
+  const char *const groups[] = {
+    "Wave::exact",
+    "grid::coordinates"};
   GenericFD_AssertGroupStorage(cctkGH, "wave_exact_sine", 2, groups);
   
   switch(fdOrder)
@@ -173,7 +172,7 @@ extern "C" void wave_exact_sine(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverEverything(cctkGH, &wave_exact_sine_Body);
+  GenericFD_LoopOverEverything(cctkGH, wave_exact_sine_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/Wave/src/wave_import_exact.cc b/Examples/Wave/src/wave_import_exact.cc
index 840eef7..8f8b0f8 100644
--- a/Examples/Wave/src/wave_import_exact.cc
+++ b/Examples/Wave/src/wave_import_exact.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void wave_import_exact_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -28,8 +28,6 @@ static void wave_import_exact_Body(cGH const * restrict const cctkGH, int const
   DECLARE_CCTK_PARAMETERS;
   
   
-  /* Declare finite differencing variables */
-  
   /* Include user-supplied include files */
   
   /* Initialise finite differencing variables */
@@ -57,25 +55,24 @@ static void wave_import_exact_Body(cGH const * restrict const cctkGH, int const
   CCTK_REAL const hdzi = 0.5 * dzi;
   
   /* Initialize predefined quantities */
-  CCTK_REAL const p1o1 = 1;
   CCTK_REAL const p1o12dx = 0.0833333333333333333333333333333*INV(dx);
   CCTK_REAL const p1o12dy = 0.0833333333333333333333333333333*INV(dy);
   CCTK_REAL const p1o12dz = 0.0833333333333333333333333333333*INV(dz);
-  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx)*INV(dy);
-  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx)*INV(dz);
-  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy)*INV(dz);
+  CCTK_REAL const p1o144dxdy = 0.00694444444444444444444444444444*INV(dx*dy);
+  CCTK_REAL const p1o144dxdz = 0.00694444444444444444444444444444*INV(dx*dz);
+  CCTK_REAL const p1o144dydz = 0.00694444444444444444444444444444*INV(dy*dz);
   CCTK_REAL const p1o2dx = 0.5*INV(dx);
   CCTK_REAL const p1o2dy = 0.5*INV(dy);
   CCTK_REAL const p1o2dz = 0.5*INV(dz);
   CCTK_REAL const p1o4dx2 = 0.25*INV(SQR(dx));
-  CCTK_REAL const p1o4dxdy = 0.25*INV(dx)*INV(dy);
-  CCTK_REAL const p1o4dxdz = 0.25*INV(dx)*INV(dz);
+  CCTK_REAL const p1o4dxdy = 0.25*INV(dx*dy);
+  CCTK_REAL const p1o4dxdz = 0.25*INV(dx*dz);
   CCTK_REAL const p1o4dy2 = 0.25*INV(SQR(dy));
-  CCTK_REAL const p1o4dydz = 0.25*INV(dy)*INV(dz);
+  CCTK_REAL const p1o4dydz = 0.25*INV(dy*dz);
   CCTK_REAL const p1o4dz2 = 0.25*INV(SQR(dz));
   CCTK_REAL const p1odx = INV(dx);
   CCTK_REAL const p1odx2 = INV(SQR(dx));
-  CCTK_REAL const p1odxdydz = INV(dx)*INV(dy)*INV(dz);
+  CCTK_REAL const p1odxdydz = INV(dx*dy*dz);
   CCTK_REAL const p1ody = INV(dy);
   CCTK_REAL const p1ody2 = INV(SQR(dy));
   CCTK_REAL const p1odz = INV(dz);
@@ -97,9 +94,9 @@ static void wave_import_exact_Body(cGH const * restrict const cctkGH, int const
   
   /* Loop over the grid points */
   #pragma omp parallel
-  CCTK_LOOP3 (wave_import_exact,
+  CCTK_LOOP3(wave_import_exact,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
@@ -131,7 +128,7 @@ static void wave_import_exact_Body(cGH const * restrict const cctkGH, int const
     phi[index] = phiL;
     pi[index] = piL;
   }
-  CCTK_ENDLOOP3 (wave_import_exact);
+  CCTK_ENDLOOP3(wave_import_exact);
 }
 
 extern "C" void wave_import_exact(CCTK_ARGUMENTS)
@@ -150,7 +147,9 @@ extern "C" void wave_import_exact(CCTK_ARGUMENTS)
     return;
   }
   
-  const char *groups[] = {"Wave::evolved","Wave::exact"};
+  const char *const groups[] = {
+    "Wave::evolved",
+    "Wave::exact"};
   GenericFD_AssertGroupStorage(cctkGH, "wave_import_exact", 2, groups);
   
   switch(fdOrder)
@@ -162,7 +161,7 @@ extern "C" void wave_import_exact(CCTK_ARGUMENTS)
       break;
   }
   
-  GenericFD_LoopOverEverything(cctkGH, &wave_import_exact_Body);
+  GenericFD_LoopOverEverything(cctkGH, wave_import_exact_Body);
   
   if (verbose > 1)
   {
diff --git a/Examples/WaveCaKernel/cakernel.ccl b/Examples/WaveCaKernel/cakernel.ccl
index 3df4bbb..f756f91 100644
--- a/Examples/WaveCaKernel/cakernel.ccl
+++ b/Examples/WaveCaKernel/cakernel.ccl
@@ -1,90 +1,29 @@
 CCTK_CUDA_KERNEL calc_rhs_2 TYPE=gpu_cuda/3dblock TILE="8,8,8" SHARECODE=yes STENCIL="1,1,1,1,1,1"
 {
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in
-  {
-    phi
-  }
-  "phi"
-  
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out
-  {
-    phirhs
-  }
-  "phirhs"
-  
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in
-  {
-    pi
-  }
-  "pi"
-  
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out
-  {
-    pirhs
-  }
-  "pirhs"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in {phi} "phi"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out {phirhs} "phirhs"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in {pi} "pi"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out {pirhs} "pirhs"
 }
 
 CCTK_CUDA_KERNEL calc_rhs_4 TYPE=gpu_cuda/3dblock TILE="8,8,8" SHARECODE=yes STENCIL="2,2,2,2,2,2"
 {
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in
-  {
-    phi
-  }
-  "phi"
-  
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out
-  {
-    phirhs
-  }
-  "phirhs"
-  
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in
-  {
-    pi
-  }
-  "pi"
-  
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out
-  {
-    pirhs
-  }
-  "pirhs"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in {phi} "phi"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out {phirhs} "phirhs"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in {pi} "pi"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out {pirhs} "pirhs"
 }
 
 CCTK_CUDA_KERNEL calc_bound_rhs TYPE=gpu_cuda/boundary_s TILE="8,8,8" SHARECODE=yes
 {
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out
-  {
-    phirhs
-  }
-  "phirhs"
-  
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out
-  {
-    pirhs
-  }
-  "pirhs"
-  
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in
-  {
-    xCopy
-  }
-  "xCopy"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out {phirhs} "phirhs"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=out {pirhs} "pirhs"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=in {xCopy} "xCopy"
 }
 
 CCTK_CUDA_KERNEL copy_to_device TYPE=gpu_cuda/3dblock TILE="8,8,8" SHARECODE=yes STENCIL="0,0,0,0,0,0"
 {
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=inout
-  {
-    phi
-  }
-  "phi"
-  
-  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=inout
-  {
-    pi
-  }
-  "pi"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=inout {phi} "phi"
+  CCTK_CUDA_KERNEL_VARIABLE  cached=no intent=inout {pi} "pi"
 }
 
diff --git a/Examples/WaveCaKernel/configuration.ccl b/Examples/WaveCaKernel/configuration.ccl
index 46dbde5..6d94724 100644
--- a/Examples/WaveCaKernel/configuration.ccl
+++ b/Examples/WaveCaKernel/configuration.ccl
@@ -4,4 +4,4 @@ REQUIRES GenericFD
 OPTIONAL LoopControl
 {
 }
-REQUIRES CUDA
\ No newline at end of file
+REQUIRES CUDA MPI
diff --git a/Examples/WaveCaKernel/interface.ccl b/Examples/WaveCaKernel/interface.ccl
index 11c1416..1d883f5 100644
--- a/Examples/WaveCaKernel/interface.ccl
+++ b/Examples/WaveCaKernel/interface.ccl
@@ -2,13 +2,14 @@
 
 implements: WaveCaKernel
 
-inherits:   Grid GenericFD Boundary
+inherits:   Grid GenericFD Boundary Accelerator
 
 
 
 USES INCLUDE: GenericFD.h
 USES INCLUDE: Symmetry.h
 USES INCLUDE: sbp_calc_coeffs.h
+USES INCLUDE: CaCUDALib_driver_support.h
 USES INCLUDE: Boundary.h
 USES INCLUDE: loopcontrol.h
 
diff --git a/Examples/WaveCaKernel/schedule.ccl b/Examples/WaveCaKernel/schedule.ccl
index 74879b1..9dea53b 100644
--- a/Examples/WaveCaKernel/schedule.ccl
+++ b/Examples/WaveCaKernel/schedule.ccl
@@ -57,100 +57,100 @@ schedule WaveCaKernel_RegisterSymmetries in SymmetryRegister
 schedule initial_gaussian AT INITIAL
 {
   LANG: C
-  READS:    grid::coordinates
-  WRITES:   WaveCaKernel::phi_g
-  WRITES:   WaveCaKernel::pi_g
-  WRITES:   WaveCaKernel::xCopy_g
+  READS:    grid::x
+  WRITES:   WaveCaKernel::phi
+  WRITES:   WaveCaKernel::pi
+  WRITES:   WaveCaKernel::xCopy
 } "initial_gaussian"
 
 
 if (fdOrder == 2)
 {
-  schedule CAKERNEL_Launch_calc_rhs_2 in MoL_CalcRHS
+  schedule CAKERNEL_Launch_calc_rhs_2 as calc_rhs_2 in MoL_CalcRHS
   {
     LANG: C
     TAGS: Device=1
-    READS:    WaveCaKernel::phi_g
-    READS:    WaveCaKernel::pi_g
-    WRITES:   WaveCaKernel::phi_grhs
-    WRITES:   WaveCaKernel::pi_grhs
+    READS:    WaveCaKernel::phi
+    READS:    WaveCaKernel::pi
+    WRITES:   WaveCaKernel::phirhs
+    WRITES:   WaveCaKernel::pirhs
   } "calc_rhs_2"
 }
 
 
 if (fdOrder == 2)
 {
-  schedule CAKERNEL_Launch_calc_rhs_2 at ANALYSIS
+  schedule CAKERNEL_Launch_calc_rhs_2 as calc_rhs_2 at ANALYSIS
   {
     LANG: C
     SYNC: phi_grhs
     SYNC: pi_grhs
     TAGS: Device=1
-    READS:    WaveCaKernel::phi_g
-    READS:    WaveCaKernel::pi_g
-    WRITES:   WaveCaKernel::phi_grhs
-    WRITES:   WaveCaKernel::pi_grhs
+    READS:    WaveCaKernel::phi
+    READS:    WaveCaKernel::pi
+    WRITES:   WaveCaKernel::phirhs
+    WRITES:   WaveCaKernel::pirhs
   } "calc_rhs_2"
 }
 
 
 if (fdOrder == 4)
 {
-  schedule CAKERNEL_Launch_calc_rhs_4 in MoL_CalcRHS
+  schedule CAKERNEL_Launch_calc_rhs_4 as calc_rhs_4 in MoL_CalcRHS
   {
     LANG: C
     TAGS: Device=1
-    READS:    WaveCaKernel::phi_g
-    READS:    WaveCaKernel::pi_g
-    WRITES:   WaveCaKernel::phi_grhs
-    WRITES:   WaveCaKernel::pi_grhs
+    READS:    WaveCaKernel::phi
+    READS:    WaveCaKernel::pi
+    WRITES:   WaveCaKernel::phirhs
+    WRITES:   WaveCaKernel::pirhs
   } "calc_rhs_4"
 }
 
 
 if (fdOrder == 4)
 {
-  schedule CAKERNEL_Launch_calc_rhs_4 at ANALYSIS
+  schedule CAKERNEL_Launch_calc_rhs_4 as calc_rhs_4 at ANALYSIS
   {
     LANG: C
     SYNC: phi_grhs
     SYNC: pi_grhs
     TAGS: Device=1
-    READS:    WaveCaKernel::phi_g
-    READS:    WaveCaKernel::pi_g
-    WRITES:   WaveCaKernel::phi_grhs
-    WRITES:   WaveCaKernel::pi_grhs
+    READS:    WaveCaKernel::phi
+    READS:    WaveCaKernel::pi
+    WRITES:   WaveCaKernel::phirhs
+    WRITES:   WaveCaKernel::pirhs
   } "calc_rhs_4"
 }
 
-schedule CAKERNEL_Launch_calc_bound_rhs in MoL_RHSBoundaries
+schedule CAKERNEL_Launch_calc_bound_rhs as calc_bound_rhs in MoL_RHSBoundaries
 {
   LANG: C
   TAGS: Device=1
-  READS:    WaveCaKernel::xCopy_g
-  WRITES:   WaveCaKernel::phi_grhs
-  WRITES:   WaveCaKernel::pi_grhs
+  READS:    WaveCaKernel::xCopy
+  WRITES:   WaveCaKernel::phirhs
+  WRITES:   WaveCaKernel::pirhs
 } "calc_bound_rhs"
 
-schedule CAKERNEL_Launch_calc_bound_rhs at ANALYSIS
+schedule CAKERNEL_Launch_calc_bound_rhs as calc_bound_rhs at ANALYSIS
 {
   LANG: C
   SYNC: phi_grhs
   SYNC: pi_grhs
   TAGS: Device=1
-  READS:    WaveCaKernel::xCopy_g
-  WRITES:   WaveCaKernel::phi_grhs
-  WRITES:   WaveCaKernel::pi_grhs
+  READS:    WaveCaKernel::xCopy
+  WRITES:   WaveCaKernel::phirhs
+  WRITES:   WaveCaKernel::pirhs
 } "calc_bound_rhs"
 
-schedule CAKERNEL_Launch_copy_to_device at INITIAL after initial_gaussian
+schedule CAKERNEL_Launch_copy_to_device as copy_to_device at INITIAL after initial_gaussian
 {
   LANG: C
   TAGS: Device=1
-  READS:    WaveCaKernel::phi_g
-  READS:    WaveCaKernel::pi_g
-  WRITES:   WaveCaKernel::phi_g
-  WRITES:   WaveCaKernel::pi_g
+  READS:    WaveCaKernel::phi
+  READS:    WaveCaKernel::pi
+  WRITES:   WaveCaKernel::phi
+  WRITES:   WaveCaKernel::pi
 } "copy_to_device"
 
 schedule WaveCaKernel_SelectBoundConds in MoL_PostStep
@@ -173,6 +173,12 @@ schedule WaveCaKernel_RegisterVars in MoL_Register
   OPTIONS: meta
 } "Register Variables for MoL"
 
+schedule WaveCaKernel_Init in CCTK_BASEGRID after Accelerator_SetDevice
+{
+  LANG: C
+  OPTIONS: local
+} "Initialize CUDA Device"
+
 schedule group ApplyBCs as WaveCaKernel_ApplyBCs in MoL_PostStep after WaveCaKernel_SelectBoundConds
 {
   # no language specified
diff --git a/Examples/WaveCaKernel/src/CaKernel__calc_bound_rhs.code b/Examples/WaveCaKernel/src/CaKernel__calc_bound_rhs.code
index 0942be7..013ab6c 100644
--- a/Examples/WaveCaKernel/src/CaKernel__calc_bound_rhs.code
+++ b/Examples/WaveCaKernel/src/CaKernel__calc_bound_rhs.code
@@ -9,10 +9,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 CAKERNEL_calc_bound_rhs_Begin
   
diff --git a/Examples/WaveCaKernel/src/CaKernel__calc_rhs_2.code b/Examples/WaveCaKernel/src/CaKernel__calc_rhs_2.code
index b85aad1..085e274 100644
--- a/Examples/WaveCaKernel/src/CaKernel__calc_rhs_2.code
+++ b/Examples/WaveCaKernel/src/CaKernel__calc_rhs_2.code
@@ -9,10 +9,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 CAKERNEL_calc_rhs_2_Begin
   
diff --git a/Examples/WaveCaKernel/src/CaKernel__calc_rhs_4.code b/Examples/WaveCaKernel/src/CaKernel__calc_rhs_4.code
index a3f9bbc..c94216d 100644
--- a/Examples/WaveCaKernel/src/CaKernel__calc_rhs_4.code
+++ b/Examples/WaveCaKernel/src/CaKernel__calc_rhs_4.code
@@ -9,10 +9,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 CAKERNEL_calc_rhs_4_Begin
   
diff --git a/Examples/WaveCaKernel/src/CaKernel__copy_to_device.code b/Examples/WaveCaKernel/src/CaKernel__copy_to_device.code
index 76cdc9a..40f0db4 100644
--- a/Examples/WaveCaKernel/src/CaKernel__copy_to_device.code
+++ b/Examples/WaveCaKernel/src/CaKernel__copy_to_device.code
@@ -9,10 +9,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 CAKERNEL_copy_to_device_Begin
   
diff --git a/Examples/WaveCaKernel/src/initial_gaussian.cc b/Examples/WaveCaKernel/src/initial_gaussian.cc
index ad73b93..28d41e0 100644
--- a/Examples/WaveCaKernel/src/initial_gaussian.cc
+++ b/Examples/WaveCaKernel/src/initial_gaussian.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void initial_gaussian_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -86,7 +86,7 @@ static void initial_gaussian_Body(cGH const * restrict const cctkGH, int const d
   #pragma omp parallel
   CCTK_LOOP3(initial_gaussian,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
diff --git a/Examples/WaveCaKernel/test b/Examples/WaveCaKernel/test
index 35022b1..7137e86 120000
--- a/Examples/WaveCaKernel/test
+++ b/Examples/WaveCaKernel/test
@@ -1 +1 @@
-../tests/WaveCaKernel/test
\ No newline at end of file
+../tests/WaveCaKernel
\ No newline at end of file
diff --git a/Examples/WaveHost/schedule.ccl b/Examples/WaveHost/schedule.ccl
index d57c66f..b50b3de 100644
--- a/Examples/WaveHost/schedule.ccl
+++ b/Examples/WaveHost/schedule.ccl
@@ -57,10 +57,10 @@ schedule WaveHost_RegisterSymmetries in SymmetryRegister
 schedule initial_gaussian AT INITIAL
 {
   LANG: C
-  READS:    grid::coordinates
-  WRITES:   WaveHost::phi_g
-  WRITES:   WaveHost::pi_g
-  WRITES:   WaveHost::xCopy_g
+  READS:    grid::x
+  WRITES:   WaveHost::phi
+  WRITES:   WaveHost::pi
+  WRITES:   WaveHost::xCopy
 } "initial_gaussian"
 
 
@@ -69,10 +69,10 @@ if (fdOrder == 2)
   schedule calc_rhs_2 in MoL_CalcRHS
   {
     LANG: C
-    READS:    WaveHost::phi_g
-    READS:    WaveHost::pi_g
-    WRITES:   WaveHost::phi_grhs
-    WRITES:   WaveHost::pi_grhs
+    READS:    WaveHost::phi
+    READS:    WaveHost::pi
+    WRITES:   WaveHost::phirhs
+    WRITES:   WaveHost::pirhs
   } "calc_rhs_2"
 }
 
@@ -84,10 +84,10 @@ if (fdOrder == 2)
     LANG: C
     SYNC: phi_grhs
     SYNC: pi_grhs
-    READS:    WaveHost::phi_g
-    READS:    WaveHost::pi_g
-    WRITES:   WaveHost::phi_grhs
-    WRITES:   WaveHost::pi_grhs
+    READS:    WaveHost::phi
+    READS:    WaveHost::pi
+    WRITES:   WaveHost::phirhs
+    WRITES:   WaveHost::pirhs
   } "calc_rhs_2"
 }
 
@@ -97,10 +97,10 @@ if (fdOrder == 4)
   schedule calc_rhs_4 in MoL_CalcRHS
   {
     LANG: C
-    READS:    WaveHost::phi_g
-    READS:    WaveHost::pi_g
-    WRITES:   WaveHost::phi_grhs
-    WRITES:   WaveHost::pi_grhs
+    READS:    WaveHost::phi
+    READS:    WaveHost::pi
+    WRITES:   WaveHost::phirhs
+    WRITES:   WaveHost::pirhs
   } "calc_rhs_4"
 }
 
@@ -112,19 +112,19 @@ if (fdOrder == 4)
     LANG: C
     SYNC: phi_grhs
     SYNC: pi_grhs
-    READS:    WaveHost::phi_g
-    READS:    WaveHost::pi_g
-    WRITES:   WaveHost::phi_grhs
-    WRITES:   WaveHost::pi_grhs
+    READS:    WaveHost::phi
+    READS:    WaveHost::pi
+    WRITES:   WaveHost::phirhs
+    WRITES:   WaveHost::pirhs
   } "calc_rhs_4"
 }
 
 schedule calc_bound_rhs in MoL_RHSBoundaries
 {
   LANG: C
-  READS:    WaveHost::xCopy_g
-  WRITES:   WaveHost::phi_grhs
-  WRITES:   WaveHost::pi_grhs
+  READS:    WaveHost::xCopy
+  WRITES:   WaveHost::phirhs
+  WRITES:   WaveHost::pirhs
 } "calc_bound_rhs"
 
 schedule calc_bound_rhs at ANALYSIS
@@ -132,9 +132,9 @@ schedule calc_bound_rhs at ANALYSIS
   LANG: C
   SYNC: phi_grhs
   SYNC: pi_grhs
-  READS:    WaveHost::xCopy_g
-  WRITES:   WaveHost::phi_grhs
-  WRITES:   WaveHost::pi_grhs
+  READS:    WaveHost::xCopy
+  WRITES:   WaveHost::phirhs
+  WRITES:   WaveHost::pirhs
 } "calc_bound_rhs"
 
 schedule WaveHost_SelectBoundConds in MoL_PostStep
diff --git a/Examples/WaveHost/src/calc_bound_rhs.cc b/Examples/WaveHost/src/calc_bound_rhs.cc
index 0fe2b38..7c58500 100644
--- a/Examples/WaveHost/src/calc_bound_rhs.cc
+++ b/Examples/WaveHost/src/calc_bound_rhs.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void calc_bound_rhs_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -101,7 +101,7 @@ static void calc_bound_rhs_Body(cGH const * restrict const cctkGH, int const dir
   #pragma omp parallel
   CCTK_LOOP3(calc_bound_rhs,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
diff --git a/Examples/WaveHost/src/calc_rhs_2.cc b/Examples/WaveHost/src/calc_rhs_2.cc
index d93a9be..0ac68e0 100644
--- a/Examples/WaveHost/src/calc_rhs_2.cc
+++ b/Examples/WaveHost/src/calc_rhs_2.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void calc_rhs_2_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -101,7 +101,7 @@ static void calc_rhs_2_Body(cGH const * restrict const cctkGH, int const dir, in
   #pragma omp parallel
   CCTK_LOOP3(calc_rhs_2,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
diff --git a/Examples/WaveHost/src/calc_rhs_4.cc b/Examples/WaveHost/src/calc_rhs_4.cc
index 2f91d7e..e4e607b 100644
--- a/Examples/WaveHost/src/calc_rhs_4.cc
+++ b/Examples/WaveHost/src/calc_rhs_4.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 extern "C" void calc_rhs_4_SelectBCs(CCTK_ARGUMENTS)
 {
@@ -101,7 +101,7 @@ static void calc_rhs_4_Body(cGH const * restrict const cctkGH, int const dir, in
   #pragma omp parallel
   CCTK_LOOP3(calc_rhs_4,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
diff --git a/Examples/WaveHost/src/initial_gaussian.cc b/Examples/WaveHost/src/initial_gaussian.cc
index 99fd6d1..667c889 100644
--- a/Examples/WaveHost/src/initial_gaussian.cc
+++ b/Examples/WaveHost/src/initial_gaussian.cc
@@ -17,10 +17,10 @@
 
 /* Define macros used in calculations */
 #define INITVALUE (42)
-#define QAD(x) (SQR(SQR(x)))
-#define INV(x) ((1.0) / (x))
+#define INV(x) ((CCTK_REAL)1.0 / (x))
 #define SQR(x) ((x) * (x))
-#define CUB(x) ((x) * (x) * (x))
+#define CUB(x) ((x) * SQR(x))
+#define QAD(x) (SQR(SQR(x)))
 
 static void initial_gaussian_Body(cGH const * restrict const cctkGH, int const dir, int const face, CCTK_REAL const normal[3], CCTK_REAL const tangentA[3], CCTK_REAL const tangentB[3], int const imin[3], int const imax[3], int const n_subblock_gfs, CCTK_REAL * restrict const subblock_gfs[])
 {
@@ -86,7 +86,7 @@ static void initial_gaussian_Body(cGH const * restrict const cctkGH, int const d
   #pragma omp parallel
   CCTK_LOOP3(initial_gaussian,
     i,j,k, imin[0],imin[1],imin[2], imax[0],imax[1],imax[2],
-    cctk_lsh[0],cctk_lsh[1],cctk_lsh[2])
+    cctk_ash[0],cctk_ash[1],cctk_ash[2])
   {
     ptrdiff_t const index = di*i + dj*j + dk*k;
     
diff --git a/Examples/WaveHost/test b/Examples/WaveHost/test
index bbc45b0..da0a5bd 120000
--- a/Examples/WaveHost/test
+++ b/Examples/WaveHost/test
@@ -1 +1 @@
-../tests/WaveHost/test
\ No newline at end of file
+../tests/WaveHost
\ No newline at end of file
diff --git a/Examples/kranc.th b/Examples/kranc.th
index fc1625b..35497d1 100644
--- a/Examples/kranc.th
+++ b/Examples/kranc.th
@@ -66,17 +66,6 @@ LSUThorns/Vectors
 # Kranc support thorn
 KrancNumericalTools/GenericFD
 
-KrancExamples/Wave
-KrancExamples/SimpleWave
-KrancExamples/EM
-KrancExamples/Euler
-KrancExamples/EulerAuto
-KrancExamples/EulerSR
-KrancExamples/Advect
-KrancExamples/Burgers
-KrancExamples/Laplace
-KrancExamples/SimpleWaveODE
-
 CactusPUGH/PUGH
 CactusPUGH/PUGHReduce
 CactusPUGH/PUGHSlab
@@ -84,8 +73,21 @@ CactusBase/IOASCII
 Carpet/CarpetIOHDF5
 ExternalLibraries/HDF5
 ExternalLibraries/zlib
+ExternalLibraries/MPI
 CactusUtils/TimerReport
 
-CaCUDA/CaCUDAPiraha
-CaCUDA/CaCUDACFD3DWOMOL
-CaCUDA/CaCUDALib
+KrancExamples/Advect
+#KrancExamples/AdvectCaKernel
+KrancExamples/Burgers
+#KrancExamples/EM-xTensor
+KrancExamples/EM
+KrancExamples/Euler
+KrancExamples/EulerAuto
+KrancExamples/EulerSR
+KrancExamples/Laplace
+KrancExamples/SimpleWave
+KrancExamples/SimpleWaveODE
+#KrancExamples/SimpleWaveOpenCL
+KrancExamples/Wave
+#KrancExamples/WaveCaKernel
+KrancExamples/WaveHost
diff --git a/Examples/tests/WaveCaKernel/test/test.ccl b/Examples/tests/WaveCaKernel/test.ccl
index 865aa71..865aa71 100644
--- a/Examples/tests/WaveCaKernel/test/test.ccl
+++ b/Examples/tests/WaveCaKernel/test.ccl
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc.par b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc.par
index 1943c5b..1943c5b 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc.par
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc.par
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.d.asc
index 367ee87..367ee87 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.maximum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.maximum.asc
index 193c3cc..193c3cc 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.maximum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.maximum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.minimum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.minimum.asc
index 26669e9..26669e9 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.minimum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.minimum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.norm2.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.norm2.asc
index e7bc66e..e7bc66e 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.norm2.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.norm2.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.x.asc
index ee6dd45..ee6dd45 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.y.asc
index 5d7e7e9..5d7e7e9 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.z.asc
index b877ca7..b877ca7 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phi.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phi.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phirhs.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phirhs.d.asc
index 175ab11..175ab11 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phirhs.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phirhs.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phirhs.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phirhs.x.asc
index b5965c4..b5965c4 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phirhs.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phirhs.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phirhs.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phirhs.y.asc
index feba25f..feba25f 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phirhs.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phirhs.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phirhs.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phirhs.z.asc
index 94902af..94902af 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/phirhs.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/phirhs.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.d.asc
index 75fb6ed..75fb6ed 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.maximum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.maximum.asc
index 039ef15..039ef15 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.maximum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.maximum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.minimum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.minimum.asc
index 8e9023f..8e9023f 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.minimum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.minimum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.norm2.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.norm2.asc
index 5a134e4..5a134e4 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.norm2.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.norm2.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.x.asc
index 7a0908b..7a0908b 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.y.asc
index ab20619..ab20619 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.z.asc
index 18d5a3c..18d5a3c 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pi.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pi.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pirhs.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pirhs.d.asc
index 0c0b7bd..0c0b7bd 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pirhs.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pirhs.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pirhs.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pirhs.x.asc
index 487d14a..487d14a 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pirhs.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pirhs.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pirhs.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pirhs.y.asc
index 3a4ae9f..3a4ae9f 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pirhs.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pirhs.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pirhs.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pirhs.z.asc
index cae2c96..cae2c96 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_1proc/pirhs.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_1proc/pirhs.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc.par b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc.par
index 1943c5b..1943c5b 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc.par
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc.par
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.d.asc
index a0bde44..a0bde44 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.maximum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.maximum.asc
index 193c3cc..193c3cc 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.maximum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.maximum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.minimum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.minimum.asc
index 26669e9..26669e9 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.minimum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.minimum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.norm2.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.norm2.asc
index 0a9b443..0a9b443 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.norm2.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.norm2.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.x.asc
index 0e8a066..0e8a066 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.y.asc
index 9a6d239..9a6d239 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.z.asc
index 94f68a4..94f68a4 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phi.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phi.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phirhs.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phirhs.d.asc
index d89a006..d89a006 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phirhs.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phirhs.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phirhs.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phirhs.x.asc
index 5e8e06c..5e8e06c 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phirhs.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phirhs.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phirhs.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phirhs.y.asc
index 1236ded..1236ded 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phirhs.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phirhs.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phirhs.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phirhs.z.asc
index b35f2cf..b35f2cf 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/phirhs.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/phirhs.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.d.asc
index 8501e27..8501e27 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.maximum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.maximum.asc
index 039ef15..039ef15 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.maximum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.maximum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.minimum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.minimum.asc
index 8e9023f..8e9023f 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.minimum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.minimum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.norm2.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.norm2.asc
index 17b010e..17b010e 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.norm2.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.norm2.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.x.asc
index 2c26e70..2c26e70 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.y.asc
index 8ba9164..8ba9164 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.z.asc
index 4b71950..4b71950 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pi.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pi.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pirhs.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pirhs.d.asc
index 35b64b5..35b64b5 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pirhs.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pirhs.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pirhs.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pirhs.x.asc
index 588bf9f..588bf9f 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pirhs.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pirhs.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pirhs.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pirhs.y.asc
index 3f108d6..3f108d6 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pirhs.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pirhs.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pirhs.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pirhs.z.asc
index dbd0ad7..dbd0ad7 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_2proc/pirhs.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_2proc/pirhs.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc.par b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc.par
index c814871..c814871 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc.par
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc.par
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.d.asc
index d4f8ad6..d4f8ad6 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.maximum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.maximum.asc
index b4b66ff..b4b66ff 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.maximum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.maximum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.minimum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.minimum.asc
index 3c9b29d..3c9b29d 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.minimum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.minimum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.norm2.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.norm2.asc
index 3138b16..3138b16 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.norm2.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.norm2.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.x.asc
index 7cde87e..7cde87e 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.y.asc
index 35e3147..35e3147 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.z.asc
index 54dccaf..54dccaf 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phi.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phi.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phirhs.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phirhs.d.asc
index 600a2a7..600a2a7 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phirhs.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phirhs.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phirhs.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phirhs.x.asc
index 6abe3ce..6abe3ce 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phirhs.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phirhs.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phirhs.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phirhs.y.asc
index 8ef73c4..8ef73c4 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phirhs.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phirhs.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phirhs.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phirhs.z.asc
index cb8a471..cb8a471 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/phirhs.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/phirhs.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.d.asc
index ea1ea63..ea1ea63 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.maximum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.maximum.asc
index f728d27..f728d27 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.maximum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.maximum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.minimum.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.minimum.asc
index 3bbff0b..3bbff0b 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.minimum.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.minimum.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.norm2.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.norm2.asc
index 706caab..706caab 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.norm2.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.norm2.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.x.asc
index 3a0c1bc..3a0c1bc 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.y.asc
index 23044f7..23044f7 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.z.asc
index efce1ee..efce1ee 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pi.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pi.z.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pirhs.d.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pirhs.d.asc
index d5138d3..d5138d3 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pirhs.d.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pirhs.d.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pirhs.x.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pirhs.x.asc
index b68499f..b68499f 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pirhs.x.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pirhs.x.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pirhs.y.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pirhs.y.asc
index 548070a..548070a 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pirhs.y.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pirhs.y.asc
diff --git a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pirhs.z.asc b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pirhs.z.asc
index 6f86e27..6f86e27 100644
--- a/Examples/tests/WaveCaKernel/test/wavecakernel_gaussian_4_2proc/pirhs.z.asc
+++ b/Examples/tests/WaveCaKernel/wavecakernel_gaussian_4_2proc/pirhs.z.asc
diff --git a/Examples/tests/WaveHost/test/test.ccl b/Examples/tests/WaveHost/test.ccl
index d49302d..d49302d 100644
--- a/Examples/tests/WaveHost/test/test.ccl
+++ b/Examples/tests/WaveHost/test.ccl
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc.par b/Examples/tests/WaveHost/wavehost_gaussian_1proc.par
index 2e578fe..2e578fe 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc.par
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc.par
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.d.asc
index 367ee87..367ee87 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.maximum.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.maximum.asc
index 193c3cc..193c3cc 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.maximum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.maximum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.minimum.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.minimum.asc
index 26669e9..26669e9 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.minimum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.minimum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.norm2.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.norm2.asc
index e7bc66e..e7bc66e 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.norm2.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.norm2.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.x.asc
index ee6dd45..ee6dd45 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.y.asc
index 5d7e7e9..5d7e7e9 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.z.asc
index b877ca7..b877ca7 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phi.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phi.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phirhs.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phirhs.d.asc
index 175ab11..175ab11 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phirhs.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phirhs.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phirhs.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phirhs.x.asc
index b5965c4..b5965c4 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phirhs.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phirhs.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phirhs.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phirhs.y.asc
index feba25f..feba25f 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phirhs.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phirhs.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phirhs.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phirhs.z.asc
index 94902af..94902af 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/phirhs.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/phirhs.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.d.asc
index 75fb6ed..75fb6ed 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.maximum.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.maximum.asc
index 039ef15..039ef15 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.maximum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.maximum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.minimum.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.minimum.asc
index 8e9023f..8e9023f 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.minimum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.minimum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.norm2.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.norm2.asc
index 5a134e4..5a134e4 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.norm2.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.norm2.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.x.asc
index 7a0908b..7a0908b 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.y.asc
index ab20619..ab20619 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.z.asc
index 18d5a3c..18d5a3c 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pi.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pi.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pirhs.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pirhs.d.asc
index 0c0b7bd..0c0b7bd 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pirhs.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pirhs.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pirhs.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pirhs.x.asc
index 487d14a..487d14a 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pirhs.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pirhs.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pirhs.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pirhs.y.asc
index 3a4ae9f..3a4ae9f 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pirhs.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pirhs.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pirhs.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pirhs.z.asc
index cae2c96..cae2c96 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_1proc/pirhs.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_1proc/pirhs.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc.par b/Examples/tests/WaveHost/wavehost_gaussian_2proc.par
index 2e578fe..2e578fe 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc.par
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc.par
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.d.asc
index a0bde44..a0bde44 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.maximum.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.maximum.asc
index 193c3cc..193c3cc 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.maximum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.maximum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.minimum.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.minimum.asc
index 26669e9..26669e9 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.minimum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.minimum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.norm2.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.norm2.asc
index 0a9b443..0a9b443 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.norm2.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.norm2.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.x.asc
index 0e8a066..0e8a066 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.y.asc
index 9a6d239..9a6d239 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.z.asc
index 94f68a4..94f68a4 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phi.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phi.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phirhs.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phirhs.d.asc
index d89a006..d89a006 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phirhs.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phirhs.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phirhs.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phirhs.x.asc
index 5e8e06c..5e8e06c 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phirhs.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phirhs.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phirhs.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phirhs.y.asc
index 1236ded..1236ded 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phirhs.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phirhs.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phirhs.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phirhs.z.asc
index b35f2cf..b35f2cf 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/phirhs.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/phirhs.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.d.asc
index 8501e27..8501e27 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.maximum.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.maximum.asc
index 039ef15..039ef15 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.maximum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.maximum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.minimum.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.minimum.asc
index 8e9023f..8e9023f 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.minimum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.minimum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.norm2.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.norm2.asc
index 17b010e..17b010e 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.norm2.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.norm2.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.x.asc
index 2c26e70..2c26e70 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.y.asc
index 8ba9164..8ba9164 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.z.asc
index 4b71950..4b71950 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pi.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pi.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pirhs.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pirhs.d.asc
index 35b64b5..35b64b5 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pirhs.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pirhs.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pirhs.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pirhs.x.asc
index 588bf9f..588bf9f 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pirhs.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pirhs.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pirhs.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pirhs.y.asc
index 3f108d6..3f108d6 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pirhs.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pirhs.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pirhs.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pirhs.z.asc
index dbd0ad7..dbd0ad7 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_2proc/pirhs.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_2proc/pirhs.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc.par b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc.par
index b061607..b061607 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc.par
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc.par
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.d.asc
index d4f8ad6..d4f8ad6 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.maximum.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.maximum.asc
index b4b66ff..b4b66ff 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.maximum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.maximum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.minimum.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.minimum.asc
index 3c9b29d..3c9b29d 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.minimum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.minimum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.norm2.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.norm2.asc
index 3138b16..3138b16 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.norm2.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.norm2.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.x.asc
index 7cde87e..7cde87e 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.y.asc
index 35e3147..35e3147 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.z.asc
index 54dccaf..54dccaf 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phi.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phi.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phirhs.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phirhs.d.asc
index 600a2a7..600a2a7 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phirhs.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phirhs.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phirhs.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phirhs.x.asc
index 6abe3ce..6abe3ce 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phirhs.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phirhs.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phirhs.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phirhs.y.asc
index 8ef73c4..8ef73c4 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phirhs.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phirhs.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phirhs.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phirhs.z.asc
index cb8a471..cb8a471 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/phirhs.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/phirhs.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.d.asc
index ea1ea63..ea1ea63 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.maximum.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.maximum.asc
index f728d27..f728d27 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.maximum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.maximum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.minimum.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.minimum.asc
index 3bbff0b..3bbff0b 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.minimum.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.minimum.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.norm2.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.norm2.asc
index 706caab..706caab 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.norm2.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.norm2.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.x.asc
index 3a0c1bc..3a0c1bc 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.y.asc
index 23044f7..23044f7 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.z.asc
index efce1ee..efce1ee 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pi.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pi.z.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pirhs.d.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pirhs.d.asc
index d5138d3..d5138d3 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pirhs.d.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pirhs.d.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pirhs.x.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pirhs.x.asc
index b68499f..b68499f 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pirhs.x.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pirhs.x.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pirhs.y.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pirhs.y.asc
index 548070a..548070a 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pirhs.y.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pirhs.y.asc
diff --git a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pirhs.z.asc b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pirhs.z.asc
index 6f86e27..6f86e27 100644
--- a/Examples/tests/WaveHost/test/wavehost_gaussian_4_2proc/pirhs.z.asc
+++ b/Examples/tests/WaveHost/wavehost_gaussian_4_2proc/pirhs.z.asc
diff --git a/Tools/CodeGen/Calculation.m b/Tools/CodeGen/Calculation.m
index 2bc980a..a68650b 100644
--- a/Tools/CodeGen/Calculation.m
+++ b/Tools/CodeGen/Calculation.m
@@ -98,7 +98,7 @@ DefFn[
 
 DefFn[
   GetCalculationScheduleName[calc_List] :=
-  If[lookup[calc, UseCaKernel] && CalculationOnDevice[calc],
+  If[lookup[calc, UseCaKernel, False] && CalculationOnDevice[calc],
      "CAKERNEL_Launch_",""]
   <>lookup[calc, Name]];
 
diff --git a/Tools/CodeGen/CalculationFunction.m b/Tools/CodeGen/CalculationFunction.m
index 20f3bc5..1af84c4 100644
--- a/Tools/CodeGen/CalculationFunction.m
+++ b/Tools/CodeGen/CalculationFunction.m
@@ -273,7 +273,7 @@ assignVariableFromExpression[dest_, expr_, declare_, vectorise_, noSimplify:Bool
     cleanExpr = ReplacePowers[expr, vectorise, noSimplify];
 
     If[SOURCELANGUAGE == "C",
-      code = If[declare, type <> " ", ""] <> ToString[dest] <> " = " <>
+      code = If[declare, type <> " CCTK_ATTRIBUTE_UNUSED ", ""] <> ToString[dest] <> " = " <>
         ToString[cleanExpr, CForm,         PageWidth -> Infinity] <> ";\n",
       code = ToString@dest <> ".eq." <> ToString[cleanExpr, FortranForm, PageWidth -> 120]
         <> "\n"];
diff --git a/Tools/CodeGen/CodeGenC.m b/Tools/CodeGen/CodeGenC.m
index 9913534..350c64c 100644
--- a/Tools/CodeGen/CodeGenC.m
+++ b/Tools/CodeGen/CodeGenC.m
@@ -97,19 +97,19 @@ DefFn[
 DefFn[
   DeclareVariable[name:(_String|_Symbol), type_String] :=
   If[SOURCELANGUAGE == "C",
-     {type, " ",    name, " = INITVALUE" <> EOL[]},
+     {type, " ",    name, " CCTK_ATTRIBUTE_UNUSED ", " = INITVALUE" <> EOL[]},
      {type, " :: ", name, EOL[]} (* no value init here to avoid implicit SAVE attribute *)]];
 
 DefFn[
   DeclareVariableNoInit[name:(_String|_Symbol), type_String] :=
   If[SOURCELANGUAGE == "C",
-     {type, " ",    name, EOL[]},
+     {type, " ",    name, " CCTK_ATTRIBUTE_UNUSED ",EOL[]},
      {type, " :: ", name, EOL[]} (* no value init here to avoid implicit SAVE attribute *)]];
 
 DefFn[
   DeclareVariables[names_?ListQ, type_String] := 
   If[SOURCELANGUAGE == "C",
-     {type, " ",    CommaSeparated@names, EOL[]},
+     {type, " ",    CommaSeparated@names, " CCTK_ATTRIBUTE_UNUSED ", EOL[]},
      {type, " :: ", CommaSeparated@names,     EOL[]} (* no value init avoids implicit SAVE attribute *)]];
 
 DefFn[
@@ -140,7 +140,7 @@ DefFn[
 
 DefFn[
   DefineVariable[name:(_String|_Symbol), type_String, value:CodeGenBlock] :=
-  {type, " ", name, " = ", value, EOL[]}];
+  {type, " ", name, " CCTK_ATTRIBUTE_UNUSED ", " = ", value, EOL[]}];
 
 DefFn[
   AssignVariable[dest:(_String|_Symbol), src:CodeGenBlock] :=
@@ -148,7 +148,7 @@ DefFn[
 
 DefFn[
   DeclareAssignVariable[type_String, dest:(_String|_Symbol), src:CodeGenBlock] :=
-  {type, " const ", dest, " = ", src, EOL[]}];
+  {type, " const ", dest, " CCTK_ATTRIBUTE_UNUSED ", " = ", src, EOL[]}];
 
 (* comments are always done C-style because they are killed by cpp anyway *) 
 DefFn[
diff --git a/Tools/CodeGen/CodeGenCactus.m b/Tools/CodeGen/CodeGenCactus.m
index de20686..83d7e3c 100644
--- a/Tools/CodeGen/CodeGenCactus.m
+++ b/Tools/CodeGen/CodeGenCactus.m
@@ -112,7 +112,7 @@ DefFn[
 
 DefFn[
   DeclareAssignVariableInLoop[type_String, dest:(_String|_Symbol), src:(_String|_Symbol)] :=
-  {type, " const ", dest, " = vec_load(", src, ")", EOL[]}];
+  {type, " const ", dest, " CCTK_ATTRIBUTE_UNUSED = vec_load(", src, ")", EOL[]}];
 
 DefFn[
   MaybeAssignVariableInLoop[dest:(_String|_Symbol), src:(_String|_Symbol), cond:Boolean] :=
@@ -128,8 +128,8 @@ DefFn[
     {loader},
     loader[x_] := If[vectorise, {"vec_load(", x, ")"}, x];
     If[mmaCond,
-       {type, " ", dest, " = (", codeCond, ") ? ", loader[src], " : ToReal(0.0)", EOL[]},
-       {type, " ", dest, " = ", loader[src], EOL[]}]]];
+       {type, " ", dest, " CCTK_ATTRIBUTE_UNUSED = (", codeCond, ") ? ", loader[src], " : ToReal(0.0)", EOL[]},
+       {type, " ", dest, " CCTK_ATTRIBUTE_UNUSED = ", loader[src], EOL[]}]]];
 
 DefFn[
   TestForNaN[expr:CodeGenBlock] :=
diff --git a/Tools/CodeGen/Jacobian.m b/Tools/CodeGen/Jacobian.m
index 1ee48a9..4ff7506 100644
--- a/Tools/CodeGen/Jacobian.m
+++ b/Tools/CodeGen/Jacobian.m
@@ -128,26 +128,26 @@ CommentedBlock["Jacobian variable pointers",
    "if (use_jacobian) GenericFD_GroupDataPointers(cctkGH, jacobian_group,\n",
    "                                              9, jacobian_ptrs);\n",
     "\n",
-    Table[{"CCTK_REAL const *restrict const J",i,j," = use_jacobian ? jacobian_ptrs[",(i-1)*3+j-1,"] : 0;\n"},{i,1,3},{j,1,3}],
+    Table[{"CCTK_REAL const *restrict const J",i,j," CCTK_ATTRIBUTE_UNUSED = use_jacobian ? jacobian_ptrs[",(i-1)*3+j-1,"] : 0;\n"},{i,1,3},{j,1,3}],
     "\n",
-   "CCTK_REAL const *restrict jacobian_determinant_ptrs[1];\n",
+   "CCTK_REAL const *restrict jacobian_determinant_ptrs[1] CCTK_ATTRIBUTE_UNUSED;\n",
    "if (use_jacobian) GenericFD_GroupDataPointers(cctkGH, jacobian_determinant_group,\n",
    "                                              1, jacobian_determinant_ptrs);\n",
     "\n",
-    {"CCTK_REAL const *restrict const detJ = use_jacobian ? jacobian_ptrs[0] : 0;\n"},
+    {"CCTK_REAL const *restrict const detJ CCTK_ATTRIBUTE_UNUSED = use_jacobian ? jacobian_ptrs[0] : 0;\n"},
     "\n",
-   "CCTK_REAL const *restrict jacobian_inverse_ptrs[9];\n",
+   "CCTK_REAL const *restrict jacobian_inverse_ptrs[9] CCTK_ATTRIBUTE_UNUSED;\n",
    "if (use_jacobian) GenericFD_GroupDataPointers(cctkGH, jacobian_inverse_group,\n",
    "                                              9, jacobian_inverse_ptrs);\n",
     "\n",
-    Table[{"CCTK_REAL const *restrict const iJ",i,j," = use_jacobian ? jacobian_inverse_ptrs[",(i-1)*3+j-1,"] : 0;\n"},{i,1,3},{j,1,3}],
+    Table[{"CCTK_REAL const *restrict const iJ",i,j," CCTK_ATTRIBUTE_UNUSED = use_jacobian ? jacobian_inverse_ptrs[",(i-1)*3+j-1,"] : 0;\n"},{i,1,3},{j,1,3}],
    "\n",
-   "CCTK_REAL const *restrict jacobian_derivative_ptrs[18];\n",
+   "CCTK_REAL const *restrict jacobian_derivative_ptrs[18] CCTK_ATTRIBUTE_UNUSED;\n",
    "if (use_jacobian) GenericFD_GroupDataPointers(cctkGH, jacobian_derivative_group,\n",
    "                                              18, jacobian_derivative_ptrs);\n",
     "\n",
     Module[{syms = Flatten[Table[{"dJ",i,j,k},{i,1,3},{j,1,3},{k,j,3}],2]},
-      MapIndexed[{"CCTK_REAL const *restrict const ", #1, " = use_jacobian ? jacobian_derivative_ptrs[", #2-1, "] : 0;\n"} &, syms]]}];
+      MapIndexed[{"CCTK_REAL const *restrict const ", #1, "  CCTK_ATTRIBUTE_UNUSED = use_jacobian ? jacobian_derivative_ptrs[", #2-1, "] : 0;\n"} &, syms]]}];
 
 (* List of symbols which should be allowed in a calculation *)
 JacobianSymbols[] :=
diff --git a/Tools/CodeGen/Kranc.m b/Tools/CodeGen/Kranc.m
index 2e35b76..d01dd88 100644
--- a/Tools/CodeGen/Kranc.m
+++ b/Tools/CodeGen/Kranc.m
@@ -95,7 +95,8 @@ ThornOptions =
   Variables -> Automatic,
   Shorthands -> {},
   ParentDirectory -> ".",
-  GenerateScript -> False};
+  GenerateScript -> False,
+  ParameterConditions -> {}};
 
 ExecuteOn;
 Device;
diff --git a/Tools/CodeGen/KrancTensor.m b/Tools/CodeGen/KrancTensor.m
index 1bd8bdb..33635b0 100644
--- a/Tools/CodeGen/KrancTensor.m
+++ b/Tools/CodeGen/KrancTensor.m
@@ -47,12 +47,16 @@ Begin["`Private`"];
 Options[CreateKrancThornTT] = ThornOptions;
 
 CreateKrancThornTT[groups_, parentDirectory_, thornName_, opts:OptionsPattern[]] :=
-  Module[{calcs, expCalcs, expGroups, options, derivs, expDerivs, reflectionSymmetries, declaredGroups, consCalcs, expConsCalcs},
+  Module[{calcs, expCalcs, expGroups, options, derivs, expDerivs, reflectionSymmetries, declaredGroups, consCalcs, expConsCalcs, pds},
     InfoMessage[Terse, "Creating thorn "<>thornName];
     InfoMessage[Terse, "Processing tensorial arguments"];
     calcs = lookup[{opts}, Calculations];
     consCalcs = lookupDefault[{opts}, ConservationCalculations, {}];
     derivs = lookupDefault[{opts}, PartialDerivatives, {}];
+
+    pds = Union[derivs[[All,1,0]]];
+    Map[DefineDerivative, pds];
+
     Map[CheckCalculationTensors, calcs];
 
     If[OptionValue[GenerateScript], WriteScript[groups, parentDirectory, thornName, opts]];
diff --git a/Tools/CodeGen/KrancThorn.m b/Tools/CodeGen/KrancThorn.m
index 2cd4ed2..ee656e1 100644
--- a/Tools/CodeGen/KrancThorn.m
+++ b/Tools/CodeGen/KrancThorn.m
@@ -29,7 +29,7 @@ BeginPackage["KrancThorn`", {"CodeGen`", "Thorn`",
  "MapLookup`", "KrancGroups`", "Differencing`",
  "CalculationFunction`", "Errors`", "Helpers`", "CactusBoundary`",
  "KrancTensor`", "Param`", "Schedule`", "Interface`", "Kranc`", "Jacobian`",
- "ConservationCalculation`", "CaKernel`", "Calculation`"}];
+ "ConservationCalculation`", "CaKernel`", "Calculation`", "ParamCheck`"}];
 
 CreateKrancThorn::usage = "Construct a Kranc thorn";
 
@@ -189,9 +189,14 @@ CreateKrancThorn[groupsOrig_, parentDirectory_, thornName_, opts:OptionsPattern[
 
     (* Add in calculations to solve any conservation laws that have
        been provided *)
-    calcs = Join[calcs,
-      consCalcs = Flatten[Map[ProcessConservationCalculation[#,thornName] &,
-        consCalcsIn],1]];
+
+    consCalcs = Flatten[Map[ProcessConservationCalculation[#,thornName] &,
+                            consCalcsIn],1];
+
+    consCalcs = Map[Join[#, {PartialDerivatives -> partialDerivs,
+                             Implementation -> implementation}] &, consCalcs];
+
+    calcs = Join[calcs,consCalcs];
     (* Print["consCalcs = ", consCalcs]; *)
 
     consGroups = Union@Flatten[
@@ -331,7 +336,7 @@ CreateKrancThorn[groupsOrig_, parentDirectory_, thornName_, opts:OptionsPattern[
     (* Makefile *)
     InfoMessage[Terse, "Creating make file"];
     make = CreateMakefile[Join[{"Startup.cc", "RegisterSymmetries.cc"},
-                               {"RegisterMoL.cc"},
+                               {"RegisterMoL.cc"}, If[Length[OptionValue[ParameterConditions]] > 0, {"ParamCheck.cc"}, {}],
                                incFilenames,
                                Map[lookup[#, Filename] &, boundarySources]]];
 
@@ -350,7 +355,11 @@ CreateKrancThorn[groupsOrig_, parentDirectory_, thornName_, opts:OptionsPattern[
                   {Filename -> "RegisterSymmetries.cc", Contents -> symregister},
                   {Filename -> "Differencing.h", Contents -> diffHeader}},
                   MapThread[{Filename -> #1, Contents -> #2} &, 
-                            {calcFilenames, calcSources}], boundarySources]};
+                            {calcFilenames, calcSources}], boundarySources, 
+                  If[Length[OptionValue[ParameterConditions]] > 0,
+                     {{Filename -> "ParamCheck.cc",
+                      Contents -> ParameterCheckSource[thornName, OptionValue[ParameterConditions]]}},
+                     {}]]};
     InfoMessage[Terse, "Creating thorn"];
     CreateThorn[thornspec]];
 
diff --git a/Tools/CodeGen/ParamCheck.m b/Tools/CodeGen/ParamCheck.m
new file mode 100644
index 0000000..db79fb4
--- /dev/null
+++ b/Tools/CodeGen/ParamCheck.m
@@ -0,0 +1,83 @@
+
+(*  Copyright 2012 Ian Hinder
+
+    This file is part of Kranc.
+
+    Kranc is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    Kranc is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Kranc; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*)
+
+BeginPackage["ParamCheck`", {"Errors`", "Helpers`", "Kranc`", "CodeGenCactus`",
+                             "CodeGenC`", "CodeGen`"}];
+
+ParameterCheckSource;
+ParameterCheckSchedule;
+
+Begin["`Private`"];
+
+DefFn[
+  ParameterCheckSource[thornName_String, conditions_List] :=
+  {Map[IncludeFile, 
+       {"cctk.h", "cctk_Arguments.h", "cctk_Parameters.h"}],
+
+   DefineCCTKFunction[
+     thornName, "void", 
+     ConditionalOnParameterTextual[
+       "CCTK_MyProc(cctkGH) == 0",
+       Map[checkCondition, conditions]]]}];
+
+DefFn[
+  ParameterCheckSchedule[thornName_String] :=
+  {Name          -> thornName<>"_ParamCheck",
+   SchedulePoint -> "at CCTK_PARAMCHECK",
+   Options       -> "global",
+   Language      -> "C", 
+   Comment       -> "Check parameter consistency"}];
+
+DefFn[checkCondition[{cond_, error_String}] :=
+  Module[
+    {render, renderbool, paramPattern},
+
+    paramPattern = Except[True | False, _Symbol | _Parameter];
+
+    renderbool[Equal[a:paramPattern,b_String]] := {"CCTK_EQUALS(", rendervalue[a], ",\"", b,"\")"};
+    renderbool[Unequal[a:paramPattern,b_String]] := {"!CCTK_EQUALS(", rendervalue[a], ",\"", b,"\")"};
+    renderbool[Equal[a:paramPattern,b_?NumberQ]] := {rendervalue[a], " == ", rendervalue[b]};
+    renderbool[Unequal[a:paramPattern,b_?NumberQ]] := {rendervalue[a], " != ", rendervalue[b]};
+
+    renderbool[Or[a_,b_]] := {"(",renderbool[a]," || ", renderbool[b],")"};
+    renderbool[And[a_,b_]] := {"(",renderbool[a]," && ", renderbool[b],")"};
+    renderbool[Not[a_]] := {"(!", renderbool[a],")"};
+    renderbool[a:paramPattern] := ToString[a/.(Parameter[x_]->x)]; (* Boolean parameter *)
+
+    (* rendervalue[a_String] := a; -- Allow literal pass-through *)
+    rendervalue[a_?NumberQ] := ToString[a];
+    rendervalue[Parameter[a_String]] := a;
+    rendervalue[a_ /; MemberQ[params,a]] := ToString[a];
+    renderbool[x_] := ThrowError["Unexpected value in run-time conditional expression (boolean):", x, "in", cond];
+    render[x_] := ThrowError["Unexpected value in run-time conditional expression (value):", x, "in", cond];
+
+    unparen[s_] := 
+    Module[
+      {s2 = FlattenBlock[s],result},
+      result = StringReplace[FlattenBlock[s2],StartOfString ~~ "(" ~~ any__ ~~ ")" ~~ EndOfString :> any];
+      If[result === s2, result, unparen[result]]];
+
+    ConditionalOnParameterTextual[
+      unparen@renderbool[cond],
+      {"CCTK_WARN(0, ", StringDrop[Stringify[error],-1], ");\n"}]]];
+
+End[];
+
+EndPackage[];
diff --git a/Tools/CodeGen/Schedule.m b/Tools/CodeGen/Schedule.m
index 225b447..9ac7ca4 100644
--- a/Tools/CodeGen/Schedule.m
+++ b/Tools/CodeGen/Schedule.m
@@ -18,7 +18,7 @@
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *)
 
-BeginPackage["Schedule`", {"Thorn`", "KrancGroups`", "MapLookup`", "Errors`", "Helpers`", "Kranc`", "CaKernel`", "Calculation`"}];
+BeginPackage["Schedule`", {"Thorn`", "KrancGroups`", "MapLookup`", "Errors`", "Helpers`", "Kranc`", "CaKernel`", "Calculation`", "ParamCheck`"}];
 
 CreateKrancScheduleFile;
 
@@ -300,7 +300,9 @@ CreateKrancScheduleFile[calcs_, groups_, evolvedGroups_, rhsGroups_, nonevolvedG
     scheduledFunctions = 
       Join[{scheduledStartup, scheduleRegisterSymmetries}, 
         scheduledCalcs, CactusBoundary`GetScheduledFunctions[thornName, evolvedGroups],
-           {scheduleMoLRegister}];
+           {scheduleMoLRegister}, If[Length[OptionValue[ParameterConditions]] > 0,
+                                     {ParameterCheckSchedule[thornName]},
+                                     {}]];
 
     If[OptionValue[UseCaKernel],
        scheduledFunctions = Join[scheduledFunctions, CaKernelSchedule[thornName]]];
diff --git a/Tools/CodeGen/TensorTools.m b/Tools/CodeGen/TensorTools.m
index 10c6397..dc6f152 100644
--- a/Tools/CodeGen/TensorTools.m
+++ b/Tools/CodeGen/TensorTools.m
@@ -29,6 +29,7 @@ BeginPackage["TensorTools`", {"Errors`", "MapLookup`", "Kranc`"}];
 
 DefineTensor::usage = "DefineTensor[kernel] registers kernel as a \
 TensorTools tensor kernel.";
+DefineDerivative::usage = "DefineDerivative[pd] registers a symbol to be used as a derivative operator.";
 
 MakeExplicit::usage = "MakeExplicit[x] converts an expression x \
 containing abstract indices into one containing components \
@@ -145,6 +146,8 @@ replaceConflicting;
 (* This is for compatibility with MathTensor notation *)
 (*OD = PD;*)
 
+$Derivatives;
+
 Begin["`Private`"];
 
 listOfTensors = {};
@@ -154,6 +157,8 @@ upper = "u";
 lower = "l";
 delta = \[Delta]
 
+If[!ValueQ[$Derivatives], $Derivatives = {PD}];
+
 SwapIndices[x_, i1_, i2_] := 
   Module[{temp, unique},
     u = Unique[];
@@ -280,6 +285,9 @@ DefineTensor[T_] :=
     TensorAttributes[T] = {TensorWeight -> 0, Symmetries -> {}};
     T];
 
+DefineDerivative[pd_Symbol] :=
+  If[!DerivativeOperatorQ[pd], AppendTo[$Derivatives, pd]];
+
 (* -------------------------------------------------------------------------- 
    Index manipulation
    -------------------------------------------------------------------------- *)
@@ -549,7 +557,9 @@ listComponentsOfDummyIndex[x_, i:(TensorIndex[_,lower])] :=
    contractions of tensorial expressions.
 *)
 
-makeSum[x : PD[Tensor[_, __TensorIndex], __TensorIndex]] :=
+DerivativeOperatorQ[pd_] := MemberQ[$Derivatives, pd];
+
+makeSum[x : (pd_?DerivativeOperatorQ)[Tensor[_, __TensorIndex], __TensorIndex]] :=
   makeSumOverDummies[x];
 
 makeSum[f_[x___]] :=