This commit fully enables weighted reductions in LocalReduce. They have been tested on a modified TestGlobalReduce, commits will soon follow to TestGlobalReduce (as well as testsuites). There is a minor refinement to these patches that will soon go in, and some code cleanup. Please verify and confirm

git-svn-id: http://svn.cactuscode.org/arrangements/CactusBase/LocalReduce/trunk@58 7daa882c-dc44-4453-834e-278d26b18e6a

32 files changed, 7561 insertions, 3706 deletions

diff --git a/src/AvgFunctions.c b/src/AvgFunctions.c
index dd0a42a..d30dbe1 100644
--- a/src/AvgFunctions.c
+++ b/src/AvgFunctions.c
@@ -19,13 +19,18 @@ extern "C" {
 
 
 
-int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -33,6 +38,7 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -40,51 +46,52 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -104,10 +111,12 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -115,6 +124,7 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -122,6 +132,7 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -140,10 +151,12 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -151,6 +164,7 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -159,6 +173,7 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -177,11 +192,13 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -189,6 +206,7 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -197,6 +215,7 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -215,11 +234,13 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -227,21 +248,30 @@ int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
-int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -249,6 +279,7 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -256,51 +287,52 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -319,10 +351,12 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -330,6 +364,7 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -337,6 +372,7 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -355,10 +391,12 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -366,6 +404,7 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -374,6 +413,7 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -392,10 +432,12 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -403,6 +445,7 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -411,6 +454,7 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -429,10 +473,12 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -440,22 +486,30 @@ int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_VARIABLE_INT1
-int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -463,6 +517,7 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -470,51 +525,52 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT11
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT12
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT14
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT18
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -533,10 +589,12 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -544,6 +602,7 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -551,6 +610,7 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -569,10 +629,12 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -580,6 +642,7 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -588,6 +651,7 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -606,11 +670,13 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -618,6 +684,7 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -626,6 +693,7 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -644,11 +712,13 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -656,23 +726,31 @@ int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif                                                              
 
 #ifdef CCTK_VARIABLE_INT2
-int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -680,6 +758,7 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -687,51 +766,52 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT21
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT22
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT24
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT28
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -750,10 +830,12 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -761,6 +843,7 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -768,6 +851,7 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -786,10 +870,12 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -797,6 +883,7 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -805,6 +892,7 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -823,11 +911,13 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -835,6 +925,7 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -843,6 +934,7 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -861,11 +953,13 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -873,23 +967,31 @@ int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_VARIABLE_INT4
-int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -897,6 +999,7 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -904,51 +1007,52 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -967,10 +1071,12 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -978,6 +1084,7 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -985,6 +1092,7 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1003,10 +1111,12 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1014,6 +1124,7 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1022,6 +1133,7 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1040,11 +1152,13 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1052,6 +1166,7 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1060,6 +1175,7 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1078,11 +1194,13 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1090,23 +1208,31 @@ int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_VARIABLE_INT8
-int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1114,6 +1240,7 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1121,51 +1248,52 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1184,10 +1312,12 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1195,6 +1325,7 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1202,6 +1333,7 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1220,10 +1352,12 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1231,6 +1365,7 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1239,6 +1374,7 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1257,11 +1393,13 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1269,6 +1407,7 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1277,6 +1416,7 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1295,11 +1435,13 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1307,22 +1449,30 @@ int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1330,6 +1480,7 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1337,51 +1488,52 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1400,10 +1552,12 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1411,6 +1565,7 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1418,6 +1573,7 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1436,10 +1592,12 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1447,6 +1605,7 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1455,6 +1614,7 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1473,11 +1633,13 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1485,6 +1647,7 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1493,6 +1656,7 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1511,11 +1675,13 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1523,22 +1689,30 @@ int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_VARIABLE_REAL4
-int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1546,6 +1720,7 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1553,51 +1728,52 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1616,10 +1792,12 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1627,6 +1805,7 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1634,6 +1813,7 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1652,10 +1832,12 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1663,6 +1845,7 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1671,6 +1854,7 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1689,11 +1873,13 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1701,6 +1887,7 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1709,6 +1896,7 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1727,11 +1915,13 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1739,23 +1929,31 @@ int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_VARIABLE_REAL8
-int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1763,6 +1961,7 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1770,51 +1969,52 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1833,10 +2033,12 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1844,6 +2046,7 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1851,6 +2054,7 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1869,10 +2073,12 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1880,6 +2086,7 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1888,6 +2095,7 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1906,11 +2114,13 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1918,6 +2128,7 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1926,6 +2137,7 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1944,11 +2156,13 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1957,23 +2171,31 @@ int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval = (out_type) typed_vdata[sum_indices];
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1981,6 +2203,7 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1988,51 +2211,52 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2051,10 +2275,12 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2062,6 +2288,7 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2069,6 +2296,7 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2087,10 +2315,12 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2098,6 +2328,7 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2106,6 +2337,7 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2124,11 +2356,13 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2136,6 +2370,7 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2144,6 +2379,7 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2162,11 +2398,13 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2174,22 +2412,30 @@ int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2208,6 +2454,7 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2215,51 +2462,52 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2268,10 +2516,12 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2290,6 +2540,7 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2297,6 +2548,7 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2305,10 +2557,12 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2327,6 +2581,7 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2335,6 +2590,7 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2343,11 +2599,13 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2366,6 +2624,7 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2374,6 +2633,7 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2382,11 +2642,13 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2405,23 +2667,31 @@ int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2440,6 +2710,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2447,51 +2718,52 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2500,10 +2772,12 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2522,6 +2796,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2529,6 +2804,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2537,10 +2813,12 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2559,6 +2837,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2567,6 +2846,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2575,11 +2855,13 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2598,6 +2880,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2606,6 +2889,7 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2614,11 +2898,13 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2637,23 +2923,31 @@ int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2672,6 +2966,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2679,51 +2974,52 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2732,10 +3028,12 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2754,6 +3052,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2761,6 +3060,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2769,10 +3069,12 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2791,6 +3093,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2799,6 +3102,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2807,11 +3111,13 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2830,6 +3136,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2838,6 +3145,7 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2846,11 +3154,13 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2869,23 +3179,31 @@ int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2904,6 +3222,7 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2911,51 +3230,52 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2964,10 +3284,12 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2986,6 +3308,7 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2993,6 +3316,7 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3001,10 +3325,12 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd8( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd8( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3023,6 +3349,7 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3031,6 +3358,7 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3039,11 +3367,13 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd16( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd16( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3062,6 +3392,7 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3070,6 +3401,7 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3078,11 +3410,13 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = CCTK_CmplxAdd32( avg, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight) scalar.Re = scalar.Re * weight; scalar.Im = scalar.Im * weight;  avg = CCTK_CmplxAdd32( avg, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3101,12 +3435,15 @@ int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(avg, scalar)   avg = avg + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(avg, scalar, weight)   avg = avg + weight * scalar;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
diff --git a/src/Avg_Functions.h b/src/Avg_Functions.h
index 8f91883..eaf50d6 100644
--- a/src/Avg_Functions.h
+++ b/src/Avg_Functions.h
@@ -18,52 +18,52 @@ extern "C" {
 #endif
 
 /* Avg reduction functions */
-int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_BYTE(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
-int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_INT(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_INT1
-int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_INT1(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_INT2(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_INT4(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_INT8(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_REAL(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_REAL4
-int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_REAL4(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_REAL8(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_REAL16(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_COMPLEX(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_COMPLEX8(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_COMPLEX16(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Avg_COMPLEX32(int i, int weight_on, const void * const weight,  CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef __cplusplus
diff --git a/src/CountFunctions.c b/src/CountFunctions.c
index a0e9f91..a29d13e 100644
--- a/src/CountFunctions.c
+++ b/src/CountFunctions.c
@@ -17,13 +17,18 @@
 extern "C" {
 #endif
 
-int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -31,6 +36,7 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -38,51 +44,52 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -102,10 +109,12 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -113,6 +122,7 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -120,6 +130,7 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -138,10 +149,12 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -149,6 +162,7 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -157,6 +171,7 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -175,11 +190,13 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -187,6 +204,7 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -195,6 +213,7 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -213,11 +232,13 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -225,6 +246,7 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -233,13 +255,18 @@ int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
   return num_points;
 }
 
-int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -247,6 +274,7 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -254,51 +282,52 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -317,10 +346,12 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -328,6 +359,7 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -335,6 +367,7 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -353,10 +386,12 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -364,6 +399,7 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -372,6 +408,7 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -390,10 +427,12 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -401,6 +440,7 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -409,6 +449,7 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -427,10 +468,12 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -438,6 +481,7 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -447,13 +491,18 @@ int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 }
 
 #ifdef CCTK_INT1
-int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -461,6 +510,7 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -468,51 +518,52 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT11
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT12
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT14
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT18
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -531,10 +582,12 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -542,6 +595,7 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -549,6 +603,7 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -567,10 +622,12 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -578,6 +635,7 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -586,6 +644,7 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -604,11 +663,13 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -616,6 +677,7 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -624,6 +686,7 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -642,11 +705,13 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -654,6 +719,7 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -664,13 +730,18 @@ int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -678,6 +749,7 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -685,51 +757,52 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT21
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT22
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT24
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT28
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -748,10 +821,12 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -759,6 +834,7 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -766,6 +842,7 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -784,10 +861,12 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -795,6 +874,7 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -803,6 +883,7 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -821,11 +902,13 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -833,6 +916,7 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -841,6 +925,7 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -859,11 +944,13 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -871,6 +958,7 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -881,13 +969,18 @@ int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -895,6 +988,7 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -902,51 +996,52 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -965,10 +1060,12 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -976,6 +1073,7 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -983,6 +1081,7 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1001,10 +1100,12 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1012,6 +1113,7 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1020,6 +1122,7 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1038,11 +1141,13 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1050,6 +1155,7 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1058,6 +1164,7 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1076,11 +1183,13 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1088,6 +1197,7 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -1098,13 +1208,18 @@ int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1112,6 +1227,7 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1119,51 +1235,52 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1182,10 +1299,12 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1193,6 +1312,7 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1200,6 +1320,7 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1218,10 +1339,12 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1229,6 +1352,7 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1237,6 +1361,7 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1255,11 +1380,13 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1267,6 +1394,7 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1275,6 +1403,7 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1293,11 +1422,13 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1305,6 +1436,7 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -1314,13 +1446,18 @@ int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 }
 #endif
 
-int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1328,6 +1465,7 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1335,51 +1473,52 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1398,10 +1537,12 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1409,6 +1550,7 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1416,6 +1558,7 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1434,10 +1577,12 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1445,6 +1590,7 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1453,6 +1599,7 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1471,11 +1618,13 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1483,6 +1632,7 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1491,6 +1641,7 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1509,11 +1660,13 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1521,6 +1674,7 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -1530,13 +1684,18 @@ int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 }
 
 #ifdef CCTK_REAL4
-int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1544,6 +1703,7 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1551,51 +1711,52 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1614,10 +1775,12 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1625,6 +1788,7 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1632,6 +1796,7 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1650,10 +1815,12 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1661,6 +1828,7 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1669,6 +1837,7 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1687,11 +1856,13 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1699,6 +1870,7 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1707,6 +1879,7 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1725,11 +1898,13 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1737,6 +1912,7 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -1747,13 +1923,18 @@ int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1761,6 +1942,7 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1768,51 +1950,52 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1831,10 +2014,12 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1842,6 +2027,7 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1849,6 +2035,7 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1867,10 +2054,12 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1878,6 +2067,7 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1886,6 +2076,7 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1904,11 +2095,13 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1916,6 +2109,7 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1924,6 +2118,7 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1942,11 +2137,13 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1955,6 +2152,7 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (out_type) typed_vdata[sum_indices];
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -1965,13 +2163,18 @@ int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1979,6 +2182,7 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1986,51 +2190,52 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2049,10 +2254,12 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2060,6 +2267,7 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2067,6 +2275,7 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2085,10 +2294,12 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2096,6 +2307,7 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2104,6 +2316,7 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2122,11 +2335,13 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2134,6 +2349,7 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2142,6 +2358,7 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2160,11 +2377,13 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2172,6 +2391,7 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -2181,13 +2401,18 @@ int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 }
 #endif
 
-int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2206,6 +2431,7 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2213,51 +2439,52 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2266,10 +2493,12 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2288,6 +2517,7 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2295,6 +2525,7 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2303,10 +2534,12 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2325,6 +2558,7 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2333,6 +2567,7 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2341,11 +2576,13 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2364,6 +2601,7 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2372,6 +2610,7 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2380,11 +2619,13 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2403,6 +2644,7 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -2413,13 +2655,18 @@ int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2438,6 +2685,7 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2445,51 +2693,52 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2498,10 +2747,12 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2520,6 +2771,7 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2527,6 +2779,7 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2535,10 +2788,12 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2557,6 +2812,7 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2565,6 +2821,7 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2573,11 +2830,13 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2596,6 +2855,7 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2604,6 +2864,7 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2612,11 +2873,13 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2635,6 +2898,7 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -2645,13 +2909,18 @@ int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2670,6 +2939,7 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2677,51 +2947,52 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2730,10 +3001,12 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2752,6 +3025,7 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2759,6 +3033,7 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2767,10 +3042,12 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2789,6 +3066,7 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2797,6 +3075,7 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2805,11 +3084,13 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2828,6 +3109,7 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2836,6 +3118,7 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2844,11 +3127,13 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2867,6 +3152,7 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -2877,13 +3163,18 @@ int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Count_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2902,6 +3193,7 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2909,51 +3201,52 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2962,10 +3255,12 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2984,6 +3279,7 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2991,6 +3287,7 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2999,10 +3296,12 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3021,6 +3320,7 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3029,6 +3329,7 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3037,11 +3338,13 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3060,6 +3363,7 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3068,6 +3372,7 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3076,11 +3381,13 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Count, scalar) (Count).Re = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) (Count).Re = num_points;
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3099,6 +3406,7 @@ int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Count, scalar) Count = num_points;
+#define WEIGHTED_REDUCTION_OPERATION(Count, scalar, weight) Count = num_points;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
diff --git a/src/Count_Functions.h b/src/Count_Functions.h
index d760020..66f27ca 100644
--- a/src/Count_Functions.h
+++ b/src/Count_Functions.h
@@ -18,52 +18,52 @@ extern "C" {
 #endif
 
 /* Count reduction functions */
-int LocalReduce_Count_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
-int LocalReduce_Count_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_INT1
-int LocalReduce_Count_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Count_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Count_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Count_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Count_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_REAL4
-int LocalReduce_Count_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Count_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Count_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Count_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Count_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Count_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Count_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Count_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef __cplusplus
diff --git a/src/MaxFunctions.c b/src/MaxFunctions.c
index e6a9464..b6292df 100644
--- a/src/MaxFunctions.c
+++ b/src/MaxFunctions.c
@@ -18,13 +18,19 @@ extern "C" {
 #endif
 
 
-int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+
+int LocalReduce_Max_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -32,58 +38,60 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -103,10 +111,12 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #endif
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -114,13 +124,15 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -139,10 +151,12 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -150,7 +164,8 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -158,6 +173,7 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -176,11 +192,13 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -188,7 +206,8 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -196,6 +215,7 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -214,11 +234,13 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -226,21 +248,30 @@ int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
-int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Max_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -248,58 +279,60 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -318,10 +351,12 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -329,13 +364,15 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -354,10 +391,12 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -365,7 +404,8 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -373,6 +413,7 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -391,10 +432,12 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -402,7 +445,8 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -410,6 +454,7 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -428,10 +473,12 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -439,22 +486,30 @@ int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
-#ifdef CCTK_INT1
-int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+#ifdef CCTK_VARIABLE_INT1
+int LocalReduce_Max_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -462,58 +517,60 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT11
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT12
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT14
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT18
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -532,10 +589,12 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -543,13 +602,15 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -568,10 +629,12 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -579,7 +642,8 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -587,6 +651,7 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -605,11 +670,13 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -617,7 +684,8 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -625,6 +693,7 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -643,11 +712,13 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -655,23 +726,31 @@ int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif                                                              
 
-#ifdef CCTK_INT2
-int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+#ifdef CCTK_VARIABLE_INT2
+int LocalReduce_Max_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -679,58 +758,60 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT21
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT22
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT24
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT28
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -749,10 +830,12 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -760,13 +843,15 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -785,10 +870,12 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -796,7 +883,8 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -804,6 +892,7 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -822,11 +911,13 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -834,7 +925,8 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -842,6 +934,7 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -860,11 +953,13 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -872,23 +967,31 @@ int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-#ifdef CCTK_INT4
-int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+#ifdef CCTK_VARIABLE_INT4
+int LocalReduce_Max_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -896,58 +999,60 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -966,10 +1071,12 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -977,13 +1084,15 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1002,10 +1111,12 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1013,7 +1124,8 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -1021,6 +1133,7 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1039,11 +1152,13 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1051,7 +1166,8 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -1059,6 +1175,7 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1077,11 +1194,13 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1089,23 +1208,31 @@ int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-#ifdef CCTK_INT8
-int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+#ifdef CCTK_VARIABLE_INT8
+int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1113,58 +1240,60 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1183,10 +1312,12 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1194,13 +1325,15 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1219,10 +1352,12 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1230,7 +1365,8 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -1238,6 +1374,7 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1256,11 +1393,13 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1268,7 +1407,8 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -1276,6 +1416,7 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1294,11 +1435,13 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1306,22 +1449,30 @@ int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Max_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1329,58 +1480,60 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1399,10 +1552,12 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1410,13 +1565,15 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1435,10 +1592,12 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1446,7 +1605,8 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -1454,6 +1614,7 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1472,11 +1633,13 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1484,7 +1647,8 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -1492,6 +1656,7 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1510,11 +1675,13 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1522,22 +1689,30 @@ int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
-#ifdef CCTK_REAL4
-int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+#ifdef CCTK_VARIABLE_REAL4
+int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1545,58 +1720,60 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1615,10 +1792,12 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1626,13 +1805,15 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1651,10 +1832,12 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1662,7 +1845,8 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -1670,6 +1854,7 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1688,11 +1873,13 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1700,7 +1887,8 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -1708,6 +1896,7 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1726,11 +1915,13 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1738,23 +1929,31 @@ int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-#ifdef CCTK_REAL8
-int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+#ifdef CCTK_VARIABLE_REAL8
+int LocalReduce_Max_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1762,58 +1961,60 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1832,10 +2033,12 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1843,13 +2046,15 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1868,10 +2073,12 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1879,7 +2086,8 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -1887,6 +2095,7 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1905,11 +2114,13 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1917,7 +2128,8 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -1925,6 +2137,7 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1943,11 +2156,13 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1956,23 +2171,31 @@ int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval = (out_type) typed_vdata[sum_indices];
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Max_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1980,58 +2203,60 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2050,10 +2275,12 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2061,13 +2288,15 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2086,10 +2315,12 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2097,7 +2328,8 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -2105,6 +2337,7 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2123,11 +2356,13 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2135,7 +2370,8 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -2143,6 +2379,7 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2161,11 +2398,13 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2173,22 +2412,30 @@ int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0];
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Max_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2207,58 +2454,60 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2267,10 +2516,12 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2289,13 +2540,15 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2304,10 +2557,12 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2326,7 +2581,8 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -2334,6 +2590,7 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2342,11 +2599,13 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2365,7 +2624,8 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -2373,6 +2633,7 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2381,11 +2642,13 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2404,23 +2667,31 @@ int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Max_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2439,58 +2710,60 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2499,10 +2772,12 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2521,13 +2796,15 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2536,10 +2813,12 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2558,7 +2837,8 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -2566,6 +2846,7 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2574,11 +2855,13 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2597,7 +2880,8 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -2605,6 +2889,7 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2613,11 +2898,13 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2636,23 +2923,31 @@ int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Max_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2671,58 +2966,60 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2731,10 +3028,12 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2753,13 +3052,15 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2768,10 +3069,12 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2790,7 +3093,8 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -2798,6 +3102,7 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2806,11 +3111,13 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2829,7 +3136,8 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -2837,6 +3145,7 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2845,11 +3154,13 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2868,23 +3179,31 @@ int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Max_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2903,58 +3222,60 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
   switch (output_number_type_codes[i])
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2963,10 +3284,12 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2985,13 +3308,15 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3000,10 +3325,12 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3022,7 +3349,8 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -3030,6 +3358,7 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3038,11 +3367,13 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3061,7 +3392,8 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
     break;
@@ -3069,6 +3401,7 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3077,11 +3410,13 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Max, scalar)   if ((Max).Re < (scalar).Re) (Max).Re = (scalar).Re;
-#define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight) if ((Max).Re < (scalar).Re*weight) (Max).Re = (scalar).Re*weight;
+#define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3100,12 +3435,15 @@ int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define  REDUCTION_OPERATION(Max, scalar)   if (Max < scalar) Max = scalar;
-#define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
+#define WEIGHTED_REDUCTION_OPERATION(Max, scalar, weight)   if (Max < scalar*weight) Max = scalar*weight;
+#define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
diff --git a/src/Max_Functions.h b/src/Max_Functions.h
index ca2ab3f..1ce9fc9 100644
--- a/src/Max_Functions.h
+++ b/src/Max_Functions.h
@@ -18,52 +18,52 @@ extern "C" {
 #endif
 
 /* Max reduction functions */
-int LocalReduce_Max_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
-int LocalReduce_Max_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_INT1
-int LocalReduce_Max_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Max_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Max_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Max_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Max_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_REAL4
-int LocalReduce_Max_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Max_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Max_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Max_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Max_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Max_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Max_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Max_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef __cplusplus
diff --git a/src/MinFunctions.c b/src/MinFunctions.c
index 41f13ce..231fe81 100644
--- a/src/MinFunctions.c
+++ b/src/MinFunctions.c
@@ -17,20 +17,26 @@
 extern "C" {
 #endif
 
-int LocalReduce_Min_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -38,51 +44,52 @@ int LocalReduce_Min_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -102,17 +109,20 @@ int LocalReduce_Min_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #endif
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -120,6 +130,7 @@ int LocalReduce_Min_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -138,17 +149,20 @@ int LocalReduce_Min_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -157,6 +171,7 @@ int LocalReduce_Min_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -175,18 +190,21 @@ int LocalReduce_Min_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -195,6 +213,7 @@ int LocalReduce_Min_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -213,40 +232,51 @@ int LocalReduce_Min_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
-int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight) if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -254,51 +284,52 @@ int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -317,17 +348,20 @@ int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -335,6 +369,7 @@ int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -353,17 +388,20 @@ int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -372,6 +410,7 @@ int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -390,17 +429,20 @@ int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -409,6 +451,7 @@ int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -427,17 +470,20 @@ int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
     break;
@@ -447,20 +493,26 @@ int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 }
 
 #ifdef CCTK_INT1
-int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -468,51 +520,52 @@ int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT11
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT12
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT14
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT18
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -531,17 +584,20 @@ int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -549,6 +605,7 @@ int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -567,17 +624,20 @@ int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -586,6 +646,7 @@ int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -604,18 +665,21 @@ int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -624,6 +688,7 @@ int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -642,18 +707,21 @@ int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
     break;
@@ -664,20 +732,26 @@ int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -685,51 +759,52 @@ int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT21
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT22
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT24
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT28
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -748,17 +823,20 @@ int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -766,6 +844,7 @@ int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -784,17 +863,20 @@ int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -803,6 +885,7 @@ int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -821,18 +904,21 @@ int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -841,6 +927,7 @@ int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -859,18 +946,21 @@ int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
     break;
@@ -881,20 +971,26 @@ int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -902,51 +998,52 @@ int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -965,17 +1062,20 @@ int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -983,6 +1083,7 @@ int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1001,17 +1102,20 @@ int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1020,6 +1124,7 @@ int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1038,18 +1143,21 @@ int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1058,6 +1166,7 @@ int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1076,18 +1185,21 @@ int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
     break;
@@ -1098,20 +1210,26 @@ int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1119,51 +1237,52 @@ int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1182,17 +1301,20 @@ int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1200,6 +1322,7 @@ int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1218,17 +1341,20 @@ int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1237,6 +1363,7 @@ int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1255,18 +1382,21 @@ int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1275,6 +1405,7 @@ int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1293,18 +1424,21 @@ int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
     break;
@@ -1314,20 +1448,26 @@ int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 }
 #endif
 
-int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1335,51 +1475,52 @@ int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1398,17 +1539,20 @@ int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1416,6 +1560,7 @@ int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1434,17 +1579,20 @@ int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1453,6 +1601,7 @@ int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1471,18 +1620,21 @@ int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1491,6 +1643,7 @@ int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1509,18 +1662,21 @@ int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
     break;
@@ -1530,20 +1686,26 @@ int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 }
 
 #ifdef CCTK_REAL4
-int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1551,51 +1713,52 @@ int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1614,17 +1777,20 @@ int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1632,6 +1798,7 @@ int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1650,17 +1817,20 @@ int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1669,6 +1839,7 @@ int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1687,18 +1858,21 @@ int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1707,6 +1881,7 @@ int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1725,18 +1900,21 @@ int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
     break;
@@ -1747,20 +1925,26 @@ int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1768,51 +1952,52 @@ int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1831,17 +2016,20 @@ int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1849,6 +2037,7 @@ int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1867,17 +2056,20 @@ int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1886,6 +2078,7 @@ int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1904,18 +2097,21 @@ int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1924,6 +2120,7 @@ int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1942,11 +2139,13 @@ int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1954,7 +2153,8 @@ int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
     break;
@@ -1965,20 +2165,26 @@ int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -1986,51 +2192,52 @@ int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2049,17 +2256,20 @@ int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -2067,6 +2277,7 @@ int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2085,17 +2296,20 @@ int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -2104,6 +2318,7 @@ int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2122,18 +2337,21 @@ int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -2142,6 +2360,7 @@ int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2160,18 +2379,21 @@ int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0]; (num).Im = 0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
 
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
     break;
@@ -2181,13 +2403,18 @@ int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 }
 #endif
 
-int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2205,7 +2432,8 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2213,51 +2441,52 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2266,10 +2495,12 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2287,7 +2518,8 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2295,6 +2527,7 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2303,10 +2536,12 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2324,7 +2559,8 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2333,6 +2569,7 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2341,11 +2578,13 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2363,7 +2602,8 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2372,6 +2612,7 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2380,11 +2621,13 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2402,7 +2645,8 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
     break;
@@ -2413,13 +2657,18 @@ int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2437,7 +2686,8 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2445,51 +2695,52 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2498,10 +2749,12 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2519,7 +2772,8 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2527,6 +2781,7 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2535,10 +2790,12 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2556,7 +2813,8 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2565,6 +2823,7 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2573,11 +2832,13 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2595,7 +2856,8 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2604,6 +2866,7 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2612,11 +2875,13 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2634,7 +2899,8 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
     break;
@@ -2645,13 +2911,18 @@ int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2669,7 +2940,8 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2677,51 +2949,52 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2730,10 +3003,12 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2751,7 +3026,8 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2759,6 +3035,7 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2767,10 +3044,12 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2788,7 +3067,8 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2797,6 +3077,7 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2805,11 +3086,13 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2827,7 +3110,8 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2836,6 +3120,7 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2844,11 +3129,13 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2866,7 +3153,8 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
     break;
@@ -2877,13 +3165,18 @@ int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Min_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2901,7 +3194,8 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -2909,51 +3203,52 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2962,10 +3257,12 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2983,7 +3280,8 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0];
 #define EXTRA_STEP(a, b)
 
@@ -2991,6 +3289,7 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2999,10 +3298,12 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3020,7 +3321,8 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -3029,6 +3331,7 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3037,11 +3340,13 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3059,7 +3364,8 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
 
@@ -3068,6 +3374,7 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3076,11 +3383,13 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Min, scalar)   if ((Min).Re > (scalar).Re) (Min).Re = (scalar).Re;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if ((Min).Re > (scalar).Re*weight) (Min).Re = (scalar).Re*weight;
 #define REDUCTION_INITIAL(num) (num).Re = typed_vdata[0].Re; (num).Im = typed_vdata[0].Im;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3098,7 +3407,8 @@ int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) typed_vdata[sum_indices].Re;
 #endif
 
-#define  REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define REDUCTION_OPERATION(Min, scalar)   if (Min > scalar) Min = scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Min, scalar, weight)   if (Min > scalar*weight) Min = scalar*weight;
 #define REDUCTION_INITIAL(num) num = typed_vdata[0].Re;
 #define EXTRA_STEP(a, b)
     break;
diff --git a/src/Min_Functions.h b/src/Min_Functions.h
index 62fad17..a3efe12 100644
--- a/src/Min_Functions.h
+++ b/src/Min_Functions.h
@@ -18,52 +18,52 @@ extern "C" {
 #endif
 
 /* Min reduction functions */
-int LocalReduce_Min_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
-int LocalReduce_Min_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_INT1
-int LocalReduce_Min_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Min_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Min_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Min_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Min_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_REAL4
-int LocalReduce_Min_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Min_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Min_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Min_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Min_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Min_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Min_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Min_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef __cplusplus
diff --git a/src/Norm1Functions.c b/src/Norm1Functions.c
index e8ccef3..8777d86 100644
--- a/src/Norm1Functions.c
+++ b/src/Norm1Functions.c
@@ -18,13 +18,18 @@ extern "C" {
 #endif
 
 
-int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -36,6 +41,7 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -43,51 +49,52 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -111,10 +118,12 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -126,6 +135,7 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -133,6 +143,7 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -155,10 +166,12 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -170,6 +183,7 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -178,6 +192,7 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -200,11 +215,13 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -216,6 +233,7 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -224,6 +242,7 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -246,11 +265,13 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -262,21 +283,30 @@ int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
-int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -288,6 +318,7 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -295,51 +326,52 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -362,10 +394,12 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -377,6 +411,7 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -384,6 +419,7 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -406,10 +442,12 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -421,6 +459,7 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -429,6 +468,7 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -451,10 +491,12 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -466,6 +508,7 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -474,6 +517,7 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -496,10 +540,12 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -511,22 +557,31 @@ int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_INT1
-int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -538,6 +593,7 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -545,51 +601,52 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT11
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT12
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT14
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT18
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -612,10 +669,12 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -627,6 +686,7 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -634,6 +694,7 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -656,10 +717,12 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -671,6 +734,7 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -679,6 +743,7 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -701,11 +766,13 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -717,6 +784,7 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -725,6 +793,7 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -747,11 +816,13 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -763,23 +834,32 @@ int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -791,6 +871,7 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -798,51 +879,52 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT21
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT22
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT24
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT28
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -865,10 +947,12 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -880,6 +964,7 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -887,6 +972,7 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -909,10 +995,12 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -924,6 +1012,7 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -932,6 +1021,7 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -954,11 +1044,13 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -970,6 +1062,7 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -978,6 +1071,7 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1000,11 +1094,13 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1016,23 +1112,32 @@ int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1044,6 +1149,7 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1051,51 +1157,52 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1118,10 +1225,12 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1133,6 +1242,7 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1140,6 +1250,7 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1162,10 +1273,12 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1177,6 +1290,7 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1185,6 +1299,7 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1207,11 +1322,13 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1223,6 +1340,7 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1231,6 +1349,7 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1253,11 +1372,13 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1269,23 +1390,32 @@ int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1297,6 +1427,7 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1304,51 +1435,52 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1371,10 +1503,12 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1386,6 +1520,7 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1393,6 +1528,7 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1415,10 +1551,12 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1430,6 +1568,7 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1438,6 +1577,7 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1460,11 +1600,13 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1476,6 +1618,7 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1484,6 +1627,7 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1506,11 +1650,13 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1522,22 +1668,31 @@ int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1549,6 +1704,7 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1556,51 +1712,52 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1623,10 +1780,12 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1638,6 +1797,7 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1645,6 +1805,7 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1667,10 +1828,12 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1682,6 +1845,7 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1690,6 +1854,7 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1712,11 +1877,13 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1728,6 +1895,7 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1736,6 +1904,7 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1758,11 +1927,13 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1774,22 +1945,31 @@ int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_REAL4
-int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1801,6 +1981,7 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1808,51 +1989,52 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1875,10 +2057,12 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1890,6 +2074,7 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1897,6 +2082,7 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1919,10 +2105,12 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1934,6 +2122,7 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1942,6 +2131,7 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1964,11 +2154,13 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1980,6 +2172,7 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1988,6 +2181,7 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2010,11 +2204,13 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2026,23 +2222,32 @@ int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2054,6 +2259,7 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2061,51 +2267,52 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2128,10 +2335,12 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2143,6 +2352,7 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2150,6 +2360,7 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2172,10 +2383,12 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2187,6 +2400,7 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2195,6 +2409,7 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2217,11 +2432,13 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2233,6 +2450,7 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2241,6 +2459,7 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2263,11 +2482,13 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2280,23 +2501,32 @@ int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (out_type) typed_vdata[sum_indices];
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2308,6 +2538,7 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2315,51 +2546,52 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2382,10 +2614,12 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2397,6 +2631,7 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2404,6 +2639,7 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2426,10 +2662,12 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2441,6 +2679,7 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2449,6 +2688,7 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2471,11 +2711,13 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2487,6 +2729,7 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2495,6 +2738,7 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2517,11 +2761,13 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2533,22 +2779,31 @@ int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2567,6 +2822,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2574,51 +2830,52 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -2631,10 +2888,12 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP 
 
@@ -2653,6 +2912,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2660,6 +2920,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -2672,10 +2933,12 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2694,6 +2957,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2702,6 +2966,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -2714,11 +2979,13 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2737,6 +3004,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2745,6 +3013,7 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -2757,11 +3026,13 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2780,23 +3051,32 @@ int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2815,6 +3095,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2822,51 +3103,52 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -2879,10 +3161,12 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2901,6 +3185,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2908,6 +3193,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -2920,10 +3206,12 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2942,6 +3230,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2950,6 +3239,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -2962,11 +3252,13 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2985,6 +3277,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2993,6 +3286,7 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3005,11 +3299,13 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3028,23 +3324,32 @@ int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3063,6 +3368,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3070,51 +3376,52 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3127,10 +3434,12 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3149,6 +3458,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3156,6 +3466,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3168,10 +3479,12 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3190,6 +3503,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3198,6 +3512,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3210,11 +3525,13 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3233,6 +3550,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3241,6 +3559,7 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3253,11 +3572,13 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3276,23 +3597,32 @@ int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3311,6 +3641,7 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3318,51 +3649,52 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3375,10 +3707,12 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3397,6 +3731,7 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3404,6 +3739,7 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3416,10 +3752,12 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd8( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3438,6 +3776,7 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3446,6 +3785,7 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3458,11 +3798,13 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd16( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3481,6 +3823,7 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3489,6 +3832,7 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3501,11 +3845,13 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm1, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight) (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);Norm1 = CCTK_CmplxAdd32( Norm1, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3524,12 +3870,16 @@ int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm1, scalar)   Norm1 = Norm1 + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Norm1, scalar, weight)   Norm1 = Norm1 + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
diff --git a/src/Norm1_Functions.h b/src/Norm1_Functions.h
index 0ddbcee..554ec94 100644
--- a/src/Norm1_Functions.h
+++ b/src/Norm1_Functions.h
@@ -18,52 +18,52 @@ extern "C" {
 #endif
 
 /* Norm1 reduction functions */
-int LocalReduce_Norm1_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
-int LocalReduce_Norm1_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_INT1
-int LocalReduce_Norm1_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Norm1_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Norm1_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Norm1_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Norm1_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_REAL4
-int LocalReduce_Norm1_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Norm1_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Norm1_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Norm1_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Norm1_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Norm1_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Norm1_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm1_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef __cplusplus
diff --git a/src/Norm2Functions.c b/src/Norm2Functions.c
index f5bc8b4..ef5a9b3 100644
--- a/src/Norm2Functions.c
+++ b/src/Norm2Functions.c
@@ -18,13 +18,18 @@ extern "C" {
 #endif
 
 
-int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -36,6 +41,7 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -43,51 +49,52 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -111,10 +118,12 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -126,6 +135,7 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -133,6 +143,7 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -155,10 +166,12 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -170,6 +183,7 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -178,6 +192,7 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -200,11 +215,14 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -216,6 +234,7 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -224,6 +243,7 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -246,11 +266,13 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -262,21 +284,29 @@ int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
-int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -288,6 +318,7 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -295,51 +326,52 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -362,10 +394,12 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -377,6 +411,7 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -384,6 +419,7 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -406,10 +442,12 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -421,6 +459,7 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -429,6 +468,7 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -451,10 +491,13 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -466,6 +509,7 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -474,6 +518,7 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -496,10 +541,12 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -511,22 +558,30 @@ int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_INT1
-int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -538,6 +593,7 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -545,51 +601,52 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT11
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT12
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT14
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT18
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -612,10 +669,12 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -627,6 +686,7 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -634,6 +694,7 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -656,10 +717,12 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -671,6 +734,7 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -679,6 +743,7 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -701,11 +766,14 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -717,6 +785,7 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -725,6 +794,7 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -747,11 +817,13 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -763,23 +835,31 @@ int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -791,6 +871,7 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -798,51 +879,52 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT21
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT22
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT24
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT28
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -865,10 +947,12 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -880,6 +964,7 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -887,6 +972,7 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -909,10 +995,12 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -924,6 +1012,7 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -932,6 +1021,7 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -954,11 +1044,14 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -970,6 +1063,7 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -978,6 +1072,7 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1000,11 +1095,13 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1016,23 +1113,31 @@ int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1044,6 +1149,7 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1051,51 +1157,52 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1118,10 +1225,12 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1133,6 +1242,7 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1140,6 +1250,7 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1162,10 +1273,12 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1177,6 +1290,7 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1185,6 +1299,7 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1207,11 +1322,14 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1223,6 +1341,7 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1231,6 +1350,7 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1253,11 +1373,13 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1269,23 +1391,31 @@ int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1297,6 +1427,7 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1304,51 +1435,52 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1371,10 +1503,12 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1386,6 +1520,7 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1393,6 +1528,7 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1415,10 +1551,12 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1430,6 +1568,7 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1438,6 +1577,7 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1460,11 +1600,14 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1476,6 +1619,7 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1484,6 +1628,7 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1506,11 +1651,13 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1522,22 +1669,30 @@ int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1549,6 +1704,7 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1556,51 +1712,52 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1623,10 +1780,12 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1638,6 +1797,7 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1645,6 +1805,7 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1667,10 +1828,12 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1682,6 +1845,7 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1690,6 +1854,7 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1712,11 +1877,14 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1728,6 +1896,7 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1736,6 +1905,7 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1758,11 +1928,13 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1774,22 +1946,30 @@ int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_REAL4
-int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1801,6 +1981,7 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1808,51 +1989,52 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1875,10 +2057,12 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1890,6 +2074,7 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1897,6 +2082,7 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1919,10 +2105,12 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1934,6 +2122,7 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1942,6 +2131,7 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1964,11 +2154,14 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1980,6 +2173,7 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1988,6 +2182,7 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2010,11 +2205,13 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2026,23 +2223,31 @@ int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2054,6 +2259,7 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2061,51 +2267,52 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2128,10 +2335,12 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2143,6 +2352,7 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2150,6 +2360,7 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2172,10 +2383,12 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2187,6 +2400,7 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2195,6 +2409,7 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2217,11 +2432,14 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2233,6 +2451,7 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2241,6 +2460,7 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2263,11 +2483,13 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2280,23 +2502,31 @@ int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (out_type) typed_vdata[sum_indices];
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2308,6 +2538,7 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2315,51 +2546,52 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2382,10 +2614,12 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2397,6 +2631,7 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2404,6 +2639,7 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2426,10 +2662,12 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2441,6 +2679,7 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2449,6 +2688,7 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2471,11 +2711,14 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2487,6 +2730,7 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2495,6 +2739,7 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2517,11 +2762,13 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm2, scalar)   (scalar).Re = SQR((scalar).Re); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   (scalar).Re = SQR((scalar).Re*weight); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2533,22 +2780,30 @@ int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2571,6 +2826,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2578,51 +2834,52 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2635,10 +2892,12 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2661,6 +2920,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2668,6 +2928,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2680,10 +2941,12 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2706,6 +2969,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2714,6 +2978,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2726,11 +2991,13 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2753,6 +3020,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2761,6 +3029,7 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2773,11 +3042,13 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2800,23 +3071,31 @@ int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2839,6 +3118,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2846,51 +3126,52 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2903,10 +3184,12 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2929,6 +3212,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2936,6 +3220,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2948,10 +3233,12 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2974,6 +3261,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2982,6 +3270,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -2994,11 +3283,13 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3021,6 +3312,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3029,6 +3321,7 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3041,11 +3334,13 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3068,23 +3363,31 @@ int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3107,6 +3410,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3114,51 +3418,52 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3171,10 +3476,12 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3197,6 +3504,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3204,6 +3512,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3216,10 +3525,12 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3242,6 +3553,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3250,6 +3562,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3262,11 +3575,13 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3289,6 +3604,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3297,6 +3613,7 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3309,11 +3626,13 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3336,23 +3655,31 @@ int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3375,6 +3702,7 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3382,51 +3710,52 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3439,10 +3768,12 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul(scalar,scalar); Norm2 = CCTK_CmplxAdd( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3465,6 +3796,7 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3472,6 +3804,7 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3484,10 +3817,12 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar);Norm2 = CCTK_CmplxAdd8( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3510,6 +3845,7 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3518,6 +3854,7 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3530,11 +3867,13 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); Norm2 = CCTK_CmplxAdd16( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3557,6 +3896,7 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3565,6 +3905,7 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3577,11 +3918,13 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm2, scalar)   scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight) scalar.Re= scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); Norm2 = CCTK_CmplxAdd32( Norm2, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef SQR
@@ -3604,12 +3947,15 @@ int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm2, scalar)   Norm2 = Norm2 + SQR(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm2, scalar, weight)   Norm2 = Norm2 + SQR(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
diff --git a/src/Norm2_Functions.h b/src/Norm2_Functions.h
index c4da8f6..c807fb8 100644
--- a/src/Norm2_Functions.h
+++ b/src/Norm2_Functions.h
@@ -18,52 +18,52 @@ extern "C" {
 #endif
 
 /* Norm2 reduction functions */
-int LocalReduce_Norm2_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
-int LocalReduce_Norm2_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_INT1
-int LocalReduce_Norm2_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Norm2_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Norm2_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Norm2_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Norm2_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_REAL4
-int LocalReduce_Norm2_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Norm2_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Norm2_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Norm2_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Norm2_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Norm2_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Norm2_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm2_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef __cplusplus
diff --git a/src/Norm3Functions.c b/src/Norm3Functions.c
index 995307f..deacf8d 100644
--- a/src/Norm3Functions.c
+++ b/src/Norm3Functions.c
@@ -23,13 +23,18 @@ extern "C" {
 #define ABS(x)      ((x) < 0 ? -(x) : (x))
 
 
-int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -41,6 +46,7 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -48,51 +54,52 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -115,11 +122,13 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -131,6 +140,7 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -138,6 +148,7 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -159,11 +170,13 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -175,6 +188,7 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -183,6 +197,7 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -204,12 +219,14 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -221,6 +238,7 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -229,6 +247,7 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -250,12 +269,14 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -267,21 +288,29 @@ int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
-int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -293,6 +322,7 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -300,51 +330,52 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -366,11 +397,13 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -382,6 +415,7 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -389,6 +423,7 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -410,11 +445,13 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -426,6 +463,7 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -434,6 +472,7 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -455,11 +494,13 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -471,6 +512,7 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -479,6 +521,7 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -500,11 +543,13 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -516,22 +561,30 @@ int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_INT1
-int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -543,6 +596,7 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -550,51 +604,52 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT11
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT12
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT14
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT18
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -616,11 +671,13 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -632,6 +689,7 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -639,6 +697,7 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -660,11 +719,13 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -676,6 +737,7 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -684,6 +746,7 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -705,12 +768,14 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -722,6 +787,7 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -730,6 +796,7 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -751,12 +818,14 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -768,23 +837,31 @@ int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -796,6 +873,7 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -803,51 +881,52 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT21
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT22
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT24
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT28
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -869,11 +948,13 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -885,6 +966,7 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -892,6 +974,7 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -913,11 +996,13 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -929,6 +1014,7 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -937,6 +1023,7 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -958,12 +1045,14 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -975,6 +1064,7 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -983,6 +1073,7 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1004,12 +1095,14 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1021,23 +1114,31 @@ int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1049,6 +1150,7 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1056,51 +1158,52 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1122,11 +1225,13 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1138,6 +1243,7 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1145,6 +1251,7 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1166,11 +1273,13 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1182,6 +1291,7 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1190,6 +1300,7 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1211,12 +1322,14 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1228,6 +1341,7 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1236,6 +1350,7 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1257,12 +1372,14 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1274,23 +1391,31 @@ int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1302,6 +1427,7 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1309,51 +1435,52 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1375,11 +1502,13 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1391,6 +1520,7 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1398,6 +1528,7 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1419,11 +1550,13 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1435,6 +1568,7 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1443,6 +1577,7 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1464,12 +1599,14 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1481,6 +1618,7 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1489,6 +1627,7 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1510,12 +1649,14 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1527,22 +1668,30 @@ int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1554,6 +1703,7 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1561,51 +1711,52 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1627,11 +1778,13 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1643,6 +1796,7 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1650,6 +1804,7 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1671,11 +1826,13 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1687,6 +1844,7 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1695,6 +1853,7 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1716,12 +1875,14 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1733,6 +1894,7 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1741,6 +1903,7 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1762,12 +1925,14 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1779,22 +1944,30 @@ int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_REAL4
-int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1806,6 +1979,7 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1813,51 +1987,52 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1879,11 +2054,13 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1895,6 +2072,7 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1902,6 +2080,7 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1923,11 +2102,13 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1939,6 +2120,7 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1947,6 +2129,7 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1968,12 +2151,14 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1985,6 +2170,7 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1993,6 +2179,7 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2014,12 +2201,14 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2031,23 +2220,31 @@ int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2059,6 +2256,7 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2066,51 +2264,52 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2132,11 +2331,13 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2148,6 +2349,7 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2155,6 +2357,7 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2176,11 +2379,13 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2192,6 +2397,7 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2200,6 +2406,7 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2221,12 +2428,14 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2238,6 +2447,7 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2246,6 +2456,7 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2267,12 +2478,14 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2285,23 +2498,31 @@ int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (out_type) typed_vdata[sum_indices];
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2313,6 +2534,7 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2320,51 +2542,52 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2386,11 +2609,13 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2402,6 +2627,7 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2409,6 +2635,7 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2430,11 +2657,13 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar,weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2446,6 +2675,7 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2454,6 +2684,7 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2475,12 +2706,14 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2492,6 +2725,7 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2500,6 +2734,7 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2521,12 +2756,14 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
-#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define REDUCTION_OPERATION(Norm3, scalar)   (scalar).Re = CUBE_ABS((scalar).Re); (scalar).Im = CUBE_ABS((scalar).Im); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   (scalar).Re = CUBE_ABS((scalar).Re*weight); (scalar).Im = CUBE_ABS((scalar).Im*weight); Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2538,22 +2775,30 @@ int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2576,6 +2821,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2583,51 +2829,52 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2640,10 +2887,12 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2666,6 +2915,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2673,6 +2923,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2685,10 +2936,12 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2711,6 +2964,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2719,6 +2973,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2731,11 +2986,13 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2758,6 +3015,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2766,6 +3024,7 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2778,11 +3037,13 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)    scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2805,23 +3066,31 @@ int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2844,6 +3113,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2851,51 +3121,52 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2908,10 +3179,12 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2934,6 +3207,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2941,6 +3215,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2953,10 +3228,12 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2979,6 +3256,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2987,6 +3265,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -2999,11 +3278,13 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3026,6 +3307,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3034,6 +3316,7 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3046,11 +3329,13 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)    scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3073,23 +3358,31 @@ int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3112,6 +3405,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3119,51 +3413,52 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3176,10 +3471,12 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3202,6 +3499,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3209,6 +3507,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3221,10 +3520,12 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3247,6 +3548,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3255,6 +3557,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3267,11 +3570,13 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3294,6 +3599,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3302,6 +3608,7 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3314,11 +3621,13 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)    scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3341,23 +3650,31 @@ int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3380,6 +3697,7 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3387,51 +3705,52 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3444,10 +3763,12 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul(scalar, CCTK_CmplxMul(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3470,6 +3791,7 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3477,6 +3799,7 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3489,10 +3812,12 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul8(scalar, CCTK_CmplxMul8(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd8( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3515,6 +3840,7 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3523,6 +3849,7 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3535,11 +3862,13 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)   scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)  scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight;  scalar = CCTK_CmplxMul16(scalar, CCTK_CmplxMul16(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd16( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3562,6 +3891,7 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3570,6 +3900,7 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3582,11 +3913,13 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm3, scalar)    scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar, CCTK_CmplxMul32(scalar,scalar)); (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);  Norm3 = CCTK_CmplxAdd32( Norm3, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef CUBE_ABS
@@ -3609,12 +3942,15 @@ int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
 #endif
 
 #define REDUCTION_OPERATION(Norm3, scalar)   Norm3 = Norm3 + CUBE_ABS(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm3, scalar, weight)   Norm3 = Norm3 + CUBE_ABS(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
diff --git a/src/Norm3_Functions.h b/src/Norm3_Functions.h
index 3b594c5..f0cfd7e 100644
--- a/src/Norm3_Functions.h
+++ b/src/Norm3_Functions.h
@@ -18,52 +18,52 @@ extern "C" {
 #endif
 
 /* Norm3 reduction functions */
-int LocalReduce_Norm3_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
-int LocalReduce_Norm3_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_INT1
-int LocalReduce_Norm3_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Norm3_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Norm3_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Norm3_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Norm3_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_REAL4
-int LocalReduce_Norm3_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Norm3_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Norm3_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Norm3_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Norm3_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Norm3_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Norm3_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm3_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef __cplusplus
diff --git a/src/Norm4Functions.c b/src/Norm4Functions.c
index f106642..795bd23 100644
--- a/src/Norm4Functions.c
+++ b/src/Norm4Functions.c
@@ -18,13 +18,18 @@ extern "C" {
 #endif
 
 
-int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -36,6 +41,7 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -43,51 +49,52 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -111,10 +118,12 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #endif
 
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -126,6 +135,7 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -133,6 +143,7 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -155,10 +166,12 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -170,6 +183,7 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -178,6 +192,7 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -200,11 +215,13 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -216,6 +233,7 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -224,6 +242,7 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -246,11 +265,13 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -262,21 +283,29 @@ int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
-int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -288,6 +317,7 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -295,51 +325,52 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -362,10 +393,12 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -377,6 +410,7 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -384,6 +418,7 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -406,10 +441,12 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -421,6 +458,7 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -429,6 +467,7 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -451,10 +490,12 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -466,6 +507,7 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -474,6 +516,7 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -496,10 +539,12 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -511,22 +556,30 @@ int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_INT1
-int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -538,6 +591,7 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -545,51 +599,52 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT11
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT12
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT14
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT18
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -612,10 +667,12 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -627,6 +684,7 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -634,6 +692,7 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -656,10 +715,12 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -671,6 +732,7 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -679,6 +741,7 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -701,11 +764,13 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -717,6 +782,7 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -725,6 +791,7 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -747,11 +814,13 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -763,23 +832,31 @@ int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -791,6 +868,7 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -798,51 +876,52 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT21
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT22
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT24
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT28
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -865,10 +944,12 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -880,6 +961,7 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -887,6 +969,7 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -909,10 +992,12 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -924,6 +1009,7 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -932,6 +1018,7 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -954,11 +1041,13 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -970,6 +1059,7 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -978,6 +1068,7 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1000,11 +1091,13 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1016,23 +1109,31 @@ int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1044,6 +1145,7 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1051,51 +1153,52 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1118,10 +1221,12 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1133,6 +1238,7 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1140,6 +1246,7 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1162,10 +1269,12 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1177,6 +1286,7 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1185,6 +1295,7 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1207,11 +1318,13 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1223,6 +1336,7 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1231,6 +1345,7 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1253,11 +1368,13 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1269,23 +1386,31 @@ int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1297,6 +1422,7 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1304,51 +1430,52 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1371,10 +1498,12 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1386,6 +1515,7 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1393,6 +1523,7 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1415,10 +1546,12 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1430,6 +1563,7 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1438,6 +1572,7 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1460,11 +1595,13 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1476,6 +1613,7 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1484,6 +1622,7 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1506,11 +1645,13 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1522,22 +1663,30 @@ int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1549,6 +1698,7 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1556,51 +1706,52 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1623,10 +1774,12 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1638,6 +1791,7 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1645,6 +1799,7 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1667,10 +1822,12 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1682,6 +1839,7 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1690,6 +1848,7 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1712,11 +1871,13 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1728,6 +1889,7 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1736,6 +1898,7 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1758,11 +1921,13 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1774,22 +1939,30 @@ int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_REAL4
-int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1801,6 +1974,7 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1808,51 +1982,52 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1875,10 +2050,12 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1890,6 +2067,7 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1897,6 +2075,7 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1919,10 +2098,12 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1934,6 +2115,7 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1942,6 +2124,7 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1964,11 +2147,13 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1980,6 +2165,7 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1988,6 +2174,7 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2010,11 +2197,13 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2026,23 +2215,31 @@ int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2054,6 +2251,7 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2061,51 +2259,52 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2128,10 +2327,12 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2143,6 +2344,7 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2150,6 +2352,7 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2172,10 +2375,12 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2187,6 +2392,7 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2195,6 +2401,7 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2217,11 +2424,13 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2233,6 +2442,7 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2241,6 +2451,7 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2263,11 +2474,13 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2280,23 +2493,31 @@ int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval = (out_type) typed_vdata[sum_indices];
 
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2308,6 +2529,7 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2315,51 +2537,52 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2382,10 +2605,12 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight);  Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2397,6 +2622,7 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2404,6 +2630,7 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2426,10 +2653,12 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2441,6 +2670,7 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2449,6 +2679,7 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2471,11 +2702,13 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2487,6 +2720,7 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2495,6 +2729,7 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2517,11 +2752,13 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Norm4, scalar)   (scalar).Re = POWER4((scalar).Re); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   (scalar).Re = POWER4((scalar).Re*weight); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2533,22 +2770,30 @@ int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2574,7 +2819,8 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2582,51 +2828,52 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER2
@@ -2646,10 +2893,12 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2675,7 +2924,8 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2683,6 +2933,7 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2695,10 +2946,12 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2724,7 +2977,8 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2733,6 +2987,7 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2745,11 +3000,13 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2775,7 +3032,8 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2784,6 +3042,7 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2799,11 +3058,13 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2829,24 +3090,32 @@ int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2872,7 +3141,8 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2880,51 +3150,52 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2937,10 +3208,12 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2966,7 +3239,8 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2974,6 +3248,7 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -2989,10 +3264,12 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3018,7 +3295,8 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3027,6 +3305,7 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3042,11 +3321,13 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3072,7 +3353,8 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3081,6 +3363,7 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3093,11 +3376,13 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3120,24 +3405,32 @@ int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offset
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3163,7 +3456,8 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3171,51 +3465,52 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3228,10 +3523,12 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3257,7 +3554,8 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3265,6 +3563,7 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3277,10 +3576,12 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3306,7 +3607,8 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3315,6 +3617,7 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3330,11 +3633,13 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3360,7 +3665,8 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3369,6 +3675,7 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3381,11 +3688,13 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3411,24 +3720,32 @@ int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3454,7 +3771,8 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3462,51 +3780,52 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3519,10 +3838,12 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul(scalar, scalar); CCTK_CmplxMul(scalar,scalar); Norm4 = CCTK_CmplxAdd( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3548,7 +3869,8 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3556,6 +3878,7 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3568,10 +3891,12 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul8(scalar,scalar); scalar = CCTK_CmplxMul8(scalar,scalar);Norm4 = CCTK_CmplxAdd8( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3597,7 +3922,8 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3606,6 +3932,7 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3618,11 +3945,13 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul16(scalar,scalar); scalar = CCTK_CmplxMul16(scalar,scalar); Norm4 = CCTK_CmplxAdd16( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3648,7 +3977,8 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3657,6 +3987,7 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3669,11 +4000,13 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Norm4, scalar)   scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; scalar = CCTK_CmplxMul32(scalar,scalar); scalar = CCTK_CmplxMul32(scalar,scalar); Norm4 = CCTK_CmplxAdd32( Norm4, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef POWER4
@@ -3699,13 +4032,16 @@ int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) POWER2((POWER2((typed_vdata[sum_indices]).Re)+POWER2((typed_vdata[sum_indices]).Im)));
 #endif
 
-#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + scalar;
+#define REDUCTION_OPERATION(Norm4, scalar)   Norm4 = Norm4 + POWER4(scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Norm4, scalar, weight)   Norm4 = Norm4 + POWER4(scalar*weight);
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
diff --git a/src/Norm4_Functions.h b/src/Norm4_Functions.h
index ebcde7c..10eb46c 100644
--- a/src/Norm4_Functions.h
+++ b/src/Norm4_Functions.h
@@ -18,52 +18,52 @@ extern "C" {
 #endif
 
 /* Norm4 reduction functions */
-int LocalReduce_Norm4_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
-int LocalReduce_Norm4_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_INT1
-int LocalReduce_Norm4_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Norm4_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Norm4_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Norm4_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Norm4_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_REAL4
-int LocalReduce_Norm4_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Norm4_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Norm4_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Norm4_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Norm4_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Norm4_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Norm4_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Norm4_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef __cplusplus
diff --git a/src/NormInfFunctions.c b/src/NormInfFunctions.c
index 96b7eda..7663c3e 100644
--- a/src/NormInfFunctions.c
+++ b/src/NormInfFunctions.c
@@ -18,13 +18,18 @@ extern "C" {
 #endif
 
 
-int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -40,6 +45,7 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -47,51 +53,52 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -119,10 +126,12 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -138,6 +147,7 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -145,6 +155,7 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -173,8 +184,9 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -190,6 +202,7 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -198,6 +211,7 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -227,8 +241,9 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -244,6 +259,7 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -252,6 +268,7 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -281,8 +298,9 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -298,21 +316,29 @@ int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
-int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -328,6 +354,7 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -335,51 +362,52 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -406,10 +434,12 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(NormInf, scalar)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -425,6 +455,7 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -432,6 +463,7 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -460,8 +492,9 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -477,6 +510,7 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -485,6 +519,7 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -513,8 +548,9 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -530,6 +566,7 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -538,6 +575,7 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -566,8 +604,9 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -583,22 +622,30 @@ int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_INT1
-int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -614,6 +661,7 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -621,51 +669,52 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT11
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT12
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT14
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT18
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -692,10 +741,12 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(NormInf, scalar)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -711,6 +762,7 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -718,6 +770,7 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -746,8 +799,9 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -763,6 +817,7 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -771,6 +826,7 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -800,8 +856,9 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -817,6 +874,7 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -825,6 +883,7 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -854,8 +913,9 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -871,23 +931,31 @@ int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -903,6 +971,7 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -910,51 +979,52 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT21
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT22
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT24
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT28
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -981,10 +1051,12 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(NormInf, scalar)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1000,6 +1072,7 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1007,6 +1080,7 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1035,8 +1109,9 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1052,6 +1127,7 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1060,6 +1136,7 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1089,8 +1166,9 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1106,6 +1184,7 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1114,6 +1193,7 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1143,8 +1223,9 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1160,23 +1241,31 @@ int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1192,6 +1281,7 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1199,51 +1289,52 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1270,10 +1361,12 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(NormInf, scalar)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1289,6 +1382,7 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1296,6 +1390,7 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1324,8 +1419,9 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1341,6 +1437,7 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1349,6 +1446,7 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1378,8 +1476,9 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1395,6 +1494,7 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1403,6 +1503,7 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1432,8 +1533,9 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1449,23 +1551,31 @@ int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1481,6 +1591,7 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1488,51 +1599,52 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1559,10 +1671,12 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(NormInf, scalar)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1578,6 +1692,7 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1585,6 +1700,7 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1613,8 +1729,9 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1630,6 +1747,7 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1638,6 +1756,7 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1667,8 +1786,9 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1684,6 +1804,7 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1692,6 +1813,7 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1721,8 +1843,9 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1738,22 +1861,30 @@ int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1769,6 +1900,7 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1776,51 +1908,52 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1847,10 +1980,12 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(NormInf, scalar)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1866,6 +2001,7 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1873,6 +2009,7 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1901,8 +2038,9 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1918,6 +2056,7 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1926,6 +2065,7 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1955,8 +2095,9 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1972,6 +2113,7 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1980,6 +2122,7 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2009,8 +2152,9 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2026,22 +2170,30 @@ int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets,
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 #ifdef CCTK_REAL4
-int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2057,6 +2209,7 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2064,51 +2217,52 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2135,10 +2289,12 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(NormInf, scalar)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2154,6 +2310,7 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2161,6 +2318,7 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2189,8 +2347,9 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2206,6 +2365,7 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2214,6 +2374,7 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2243,8 +2404,9 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2260,6 +2422,7 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2268,6 +2431,7 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2297,8 +2461,9 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2314,23 +2479,31 @@ int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2346,6 +2519,7 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2353,51 +2527,52 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2424,10 +2599,12 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(NormInf, scalar)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2443,6 +2620,7 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2450,6 +2628,7 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2478,8 +2657,9 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2495,6 +2675,7 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2503,6 +2684,7 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2532,8 +2714,9 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2549,6 +2732,7 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2557,6 +2741,7 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2586,8 +2771,9 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2604,23 +2790,31 @@ int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets
         inval = (out_type) typed_vdata[sum_indices];
 
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2636,6 +2830,7 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2643,51 +2838,52 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2714,10 +2910,12 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(NormInf, scalar)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (NormInf).Re = MAX( (NormInf).Re, ABS((scalar).Re*weight));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2733,6 +2931,7 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2740,6 +2939,7 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2768,8 +2968,9 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX( (NormInf).Re, ABS((scalar).Re));
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2785,6 +2986,7 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2793,6 +2995,7 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2822,8 +3025,9 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2839,6 +3043,7 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2847,6 +3052,7 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2876,8 +3082,9 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2893,22 +3100,30 @@ int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offset
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
-int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2926,7 +3141,8 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2934,51 +3150,52 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -2995,10 +3212,12 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP 
 
@@ -3016,7 +3235,8 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3024,6 +3244,7 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3040,10 +3261,12 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3061,7 +3284,8 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3070,6 +3294,7 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3086,11 +3311,13 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3108,7 +3335,8 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3117,6 +3345,7 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3133,11 +3362,13 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3155,24 +3386,32 @@ int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offse
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3190,7 +3429,8 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3198,51 +3438,52 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3259,10 +3500,12 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3280,7 +3523,8 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3288,6 +3532,7 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3304,10 +3549,12 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3325,7 +3572,8 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3334,6 +3582,7 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3350,11 +3599,13 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3372,7 +3623,8 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3381,6 +3633,7 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3397,11 +3650,13 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3419,24 +3674,32 @@ int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offs
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3454,7 +3717,8 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3462,51 +3726,52 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3523,10 +3788,12 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3544,7 +3811,8 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3552,6 +3820,7 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3568,10 +3837,12 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3589,7 +3860,8 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3598,6 +3870,7 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3614,11 +3887,13 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3636,7 +3911,8 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3645,6 +3921,7 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3661,11 +3938,13 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3683,24 +3962,32 @@ int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_off
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3718,7 +4005,8 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3726,51 +4014,52 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3787,10 +4076,12 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3808,7 +4099,8 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3816,6 +4108,7 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3832,10 +4125,12 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3853,7 +4148,8 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3862,6 +4158,7 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3878,11 +4175,13 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3900,7 +4199,8 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3909,6 +4209,7 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #ifdef ABS
@@ -3925,11 +4226,13 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(NormInf, scalar)   (scalar).Re = ABS((scalar).Re); (scalar).Im = ABS((scalar).Im);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im); 
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   (scalar).Re = ABS((scalar).Re*weight); (scalar).Im = ABS((scalar).Im*weight);(NormInf).Re = MAX( (NormInf).Re, (scalar).Re); (NormInf).Im = MAX( (NormInf).Im, (scalar).Im);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3947,13 +4250,16 @@ int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_off
         inval = (CCTK_REAL16) (CCTK_Cmplx32Abs(typed_vdata[sum_indices]));
 #endif
 
-#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = NormInf + scalar;
+#define REDUCTION_OPERATION(NormInf, scalar)   NormInf = MAX(NormInf , ABS(scalar));
+#define WEIGHTED_REDUCTION_OPERATION(NormInf, scalar, weight)   NormInf = MAX(NormInf , ABS(scalar*weight));
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
     #endif
   }
-  return num_points;
+  ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
+  ierr = Util_TableSetReal(param_table_handle, weight_sum, "weight_sum");
+  return 0;
 }
 #endif
 
diff --git a/src/NormInf_Functions.h b/src/NormInf_Functions.h
index 17e9d6d..bb386d6 100644
--- a/src/NormInf_Functions.h
+++ b/src/NormInf_Functions.h
@@ -18,52 +18,52 @@ extern "C" {
 #endif
 
 /* NormInf reduction functions */
-int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
-int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_INT1
-int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_REAL4
-int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_NormInf_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef __cplusplus
diff --git a/src/ReductionAvg.c b/src/ReductionAvg.c
index fa9bd5e..dc320ae 100644
--- a/src/ReductionAvg.c
+++ b/src/ReductionAvg.c
@@ -34,55 +34,6 @@ static int ReductionAvg (int N_dims, int operator_handle,
                         const CCTK_INT output_number_type_codes[],
                         void * const output_numbers[]);
 
-/* Average (mean) reduction functions */
-int LocalReduce_Avg_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-
-int LocalReduce_Avg_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-
-#ifdef CCTK_INT1
-int LocalReduce_Avg_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif                                                              
-
-#ifdef CCTK_INT2
-int LocalReduce_Avg_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_INT4
-int LocalReduce_Avg_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_INT8
-int LocalReduce_Avg_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-int LocalReduce_Avg_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-
-#ifdef CCTK_REAL4
-int LocalReduce_Avg_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_REAL8
-int LocalReduce_Avg_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_REAL16
-int LocalReduce_Avg_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-int LocalReduce_Avg_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-
-#ifdef CCTK_COMPLEX8
-int LocalReduce_Avg_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_COMPLEX16
-int LocalReduce_Avg_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_COMPLEX32
-int LocalReduce_Avg_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
 /*@@
   @routine LocalReduce_Mean
   @author  Tom Goodale, Yaakoub Y El Khamra
@@ -201,17 +152,12 @@ static int ReductionAvg (int N_dims, int operator_handle,
   CCTK_INT * input_array_min_subscripts;
   CCTK_INT * input_array_max_subscripts;
 
-  /* excesion variables declared here */
-  int mask_on = 1;          /* mask is by default off=1 */
-  void * mask_array;        /* same dimensions/indexing as input arrays */
-  CCTK_INT mask_type_code;  /* one of the CCTK_VARIABLE_* codes */
-  CCTK_INT mask_offset;
-  CCTK_INT mask_time_level;
+  /* weight variables declared here */
+  int weight_on = 0;          /* weight is by default off=0 */
+  void const * weight;        /* pointer to the weight variable */  
+  CCTK_REAL weight_sum;
 
   /* prevent warnings for unused vars */
-  (void)(mask_array);
-  (void)(mask_offset + 0);
-  (void)(mask_time_level + 0);
   (void)(operator_handle + 0);
 
   /* set the number of points */
@@ -257,20 +203,16 @@ static int ReductionAvg (int N_dims, int operator_handle,
              N_dims, input_array_max_subscripts, "input_array_max_subscripts");  
   }
 
-  /* for masks get values from param table (it they exist) */
+  /* for weights get values from param table (it they exist) */
   if ( Util_TableQueryNKeys(param_table_handle) != 0)
   {
     ierr = 0;
-    ierr = Util_TableGetInt(param_table_handle, &mask_type_code, "mask_type_code"); 
-
-     /*   mask_valid_min, mask_valid_max; 
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_min");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_max");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_array, "mask_array");  */ 
+    /* Get the weight_on parameter and the weight_var_index parameter */
+    ierr = Util_TableGetInt(param_table_handle, &weight_on, "weight_on");
+    ierr = Util_TableGetPointerToConst(param_table_handle, &weight, "weight");
+    /* Need to add more checking here for size, storage */
   }
+
   /* reduction maps an array to a single value of the same type */
   if (M_output_numbers != N_input_arrays)
   {
@@ -305,70 +247,73 @@ static int ReductionAvg (int N_dims, int operator_handle,
     {
     /* in values type switches*/
       case CCTK_VARIABLE_BYTE:
-        num_points = LocalReduce_Avg_BYTE(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_BYTE(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       case CCTK_VARIABLE_INT:
-        num_points = LocalReduce_Avg_INT(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_INT(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_INT1
       case CCTK_VARIABLE_INT1:
-        num_points = LocalReduce_Avg_INT1(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_INT1(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif                                                              
       #ifdef CCTK_INT2
       case CCTK_VARIABLE_INT2:
-        num_points = LocalReduce_Avg_INT2(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_INT2(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT4
       case CCTK_VARIABLE_INT4:
-        num_points = LocalReduce_Avg_INT4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_INT4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT8
       case CCTK_VARIABLE_INT8:
-        num_points = LocalReduce_Avg_INT8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_INT8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;                                                                
       #endif
       case CCTK_VARIABLE_REAL:
-        num_points = LocalReduce_Avg_REAL(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_REAL(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_REAL4
       case CCTK_VARIABLE_REAL4:
-        num_points = LocalReduce_Avg_REAL4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_REAL4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL8
       case CCTK_VARIABLE_REAL8:
-        num_points = LocalReduce_Avg_REAL8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_REAL8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL16
       case CCTK_VARIABLE_REAL16:
-        num_points = LocalReduce_Avg_REAL16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif  
       case CCTK_VARIABLE_COMPLEX:
-        num_points = LocalReduce_Avg_COMPLEX(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_COMPLEX8
       case CCTK_VARIABLE_COMPLEX8:
-        num_points = LocalReduce_Avg_COMPLEX8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX16
       case CCTK_VARIABLE_COMPLEX16:
-        num_points = LocalReduce_Avg_COMPLEX16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX32
       case CCTK_VARIABLE_COMPLEX32:
-        num_points = LocalReduce_Avg_COMPLEX32(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Avg_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
     }
   }
 
+  /* Get the values of num_points and weight_sum */
+  ierr = Util_TableGetInt(param_table_handle, &num_points, "num_points");
+  ierr = Util_TableGetReal(param_table_handle, &weight_sum, "weight_sum");
   num_points--;
 
   /* store the number of points in the paramater table  and perform division */
@@ -377,82 +322,168 @@ static int ReductionAvg (int N_dims, int operator_handle,
   {
     ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
     ierr = Util_TableSetInt(param_table_handle, 3,"global_operation");
-    
     ierr = Util_TableSetInt(param_table_handle, 0,"perform_division");
   }
   else
   {
-    for (i = 0; i< M_output_numbers; i++)
+    if (weight_on == 1)
+    {
+      if (ABS(weight_sum) > 1e-12)
+      {
+        for (i = 0; i< M_output_numbers; i++)
+        {
+          switch (output_number_type_codes[i])
+          {
+           /* out values type switches*/
+            case CCTK_VARIABLE_BYTE:
+              *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / weight_sum; 
+            break;
+            case CCTK_VARIABLE_INT:
+              *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / weight_sum; 
+            break;
+            #ifdef CCTK_INT1
+            case CCTK_VARIABLE_INT1:
+              *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif                                                              
+            #ifdef CCTK_INT2
+            case CCTK_VARIABLE_INT2:
+              *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_INT4
+            case CCTK_VARIABLE_INT4:
+              *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_INT8
+            case CCTK_VARIABLE_INT8:
+              *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / weight_sum; 
+            break;                                                                
+            #endif
+            case CCTK_VARIABLE_REAL:
+              *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / weight_sum; 
+            break;
+            #ifdef CCTK_REAL4
+            case CCTK_VARIABLE_REAL4:
+              *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_REAL8
+            case CCTK_VARIABLE_REAL8:
+              *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_REAL16
+            case CCTK_VARIABLE_REAL16:
+              *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            case CCTK_VARIABLE_COMPLEX:
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #ifdef CCTK_COMPLEX8
+            case CCTK_VARIABLE_COMPLEX8:
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX16
+            case CCTK_VARIABLE_COMPLEX16:
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; 
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX32
+            case CCTK_VARIABLE_COMPLEX32:
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #endif
+          }
+        }
+      }
+      else
+      {
+        CCTK_WARN (1, "The sum of weights in average reduction is zero");
+        return (-1);
+      }
+    }
+    else
     {
-      switch (output_number_type_codes[i])
+      for (i = 0; i< M_output_numbers; i++)
       {
-       /* out values type switches*/
-        case CCTK_VARIABLE_BYTE:
-          *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
-        break;
-        case CCTK_VARIABLE_INT:
-          *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
-        break;
-        #ifdef CCTK_INT1
-        case CCTK_VARIABLE_INT1:
-          *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
-        break;
-        #endif                                                              
-        #ifdef CCTK_INT2
-        case CCTK_VARIABLE_INT2:
-          *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_INT4
-        case CCTK_VARIABLE_INT4:
-          *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_INT8
-        case CCTK_VARIABLE_INT8:
-          *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
-        break;                                                                
-        #endif
-        case CCTK_VARIABLE_REAL:
-          *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
-        break;
-        #ifdef CCTK_REAL4
-        case CCTK_VARIABLE_REAL4:
-          *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_REAL8
-        case CCTK_VARIABLE_REAL8:
-          *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_REAL16
-        case CCTK_VARIABLE_REAL16:
-          *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        case CCTK_VARIABLE_COMPLEX:
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
-        break;
-        #ifdef CCTK_COMPLEX8
-        case CCTK_VARIABLE_COMPLEX8:
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX16
-        case CCTK_VARIABLE_COMPLEX16:
+        switch (output_number_type_codes[i])
+        {
+         /* out values type switches*/
+          case CCTK_VARIABLE_BYTE:
+            *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
+          break;
+          case CCTK_VARIABLE_INT:
+            *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
+          break;
+          #ifdef CCTK_INT1
+          case CCTK_VARIABLE_INT1:
+            *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
+          break;
+          #endif                                                              
+          #ifdef CCTK_INT2
+          case CCTK_VARIABLE_INT2:
+            *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_INT4
+          case CCTK_VARIABLE_INT4:
+            *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_INT8
+          case CCTK_VARIABLE_INT8:
+            *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
+          break;                                                                
+          #endif
+          case CCTK_VARIABLE_REAL:
+            *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
+          break;
+          #ifdef CCTK_REAL4
+          case CCTK_VARIABLE_REAL4:
+            *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_REAL8
+          case CCTK_VARIABLE_REAL8:
+            *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_REAL16
+          case CCTK_VARIABLE_REAL16:
+            *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          case CCTK_VARIABLE_COMPLEX:
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
+          break;
+          #ifdef CCTK_COMPLEX8
+          case CCTK_VARIABLE_COMPLEX8:
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX16
+          case CCTK_VARIABLE_COMPLEX16:
           (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
           (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX32
-        case CCTK_VARIABLE_COMPLEX32:
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
-        break;
-        #endif
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX32
+          case CCTK_VARIABLE_COMPLEX32:
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
+          break;
+          #endif
+        }
       }
     }
   }
diff --git a/src/ReductionCount.c b/src/ReductionCount.c
index 41f7689..adf43bd 100644
--- a/src/ReductionCount.c
+++ b/src/ReductionCount.c
@@ -137,6 +137,7 @@ static int ReductionCount (int N_dims, int operator_handle,
   int i, j, num_points;
   int ierr;
   int * iters_per_dim;
+  int global_calling = 0;
 
   /* indices to hold the temp indices of size N_dims  and iteration indices*/
   int * indices;
@@ -151,17 +152,12 @@ static int ReductionCount (int N_dims, int operator_handle,
   CCTK_INT * input_array_min_subscripts;
   CCTK_INT * input_array_max_subscripts;
 
-  /* excesion variables declared here */
-  int mask_on = 1;          /* mask is by default off=1 */
-  void * mask_array;        /* same dimensions/indexing as input arrays */
-  CCTK_INT mask_type_code;  /* one of the CCTK_VARIABLE_* codes */
-  CCTK_INT mask_offset;
-  CCTK_INT mask_time_level;
+  /* weight variables declared here */
+  int weight_on = 0;          /* weight is by default off=0 */
+  void const * weight;        /* pointer to the weight variable */  
+  CCTK_REAL weight_sum;
 
   /* prevent warnings for unused vars */
-  (void)(mask_array);
-  (void)(mask_offset + 0);
-  (void)(mask_time_level + 0);
   (void)(operator_handle + 0);
 
   /* set the number of points */
@@ -207,20 +203,16 @@ static int ReductionCount (int N_dims, int operator_handle,
               N_dims, input_array_max_subscripts, "input_array_max_subscripts");  
   }
 
-  /* for masks get values from param table (it they exist) */
+  /* for weights get values from param table (it they exist) */
   if ( Util_TableQueryNKeys(param_table_handle) != 0)
   {
     ierr = 0;
-    ierr = Util_TableGetInt(param_table_handle, &mask_type_code, "mask_type_code"); 
-
-     /*   mask_valid_min, mask_valid_max; 
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_min");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_max");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_array, "mask_array");  */ 
+    /* Get the weight_on parameter and the weight_var_index parameter */
+    ierr = Util_TableGetInt(param_table_handle, &weight_on, "weight_on");
+    ierr = Util_TableGetPointerToConst(param_table_handle, &weight, "weight");
+    /* Need to add more checking here for size, storage */
   }
+
   /* reduction maps an array to a single value of the same type */
   if (M_output_numbers != N_input_arrays)
   {
@@ -255,79 +247,91 @@ static int ReductionCount (int N_dims, int operator_handle,
     {
     /* in values type switches*/
       case CCTK_VARIABLE_BYTE:
-        num_points = LocalReduce_Count_BYTE(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_BYTE(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       case CCTK_VARIABLE_INT:
-        num_points = LocalReduce_Count_INT(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_INT(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_INT1
       case CCTK_VARIABLE_INT1:
-        num_points = LocalReduce_Count_INT1(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_INT1(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif                                                              
       #ifdef CCTK_INT2
       case CCTK_VARIABLE_INT2:
-        num_points = LocalReduce_Count_INT2(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_INT2(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT4
       case CCTK_VARIABLE_INT4:
-        num_points = LocalReduce_Count_INT4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_INT4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT8
       case CCTK_VARIABLE_INT8:
-        num_points = LocalReduce_Count_INT8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_INT8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;                                                                
       #endif
       case CCTK_VARIABLE_REAL:
-        num_points = LocalReduce_Count_REAL(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_REAL(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_REAL4
       case CCTK_VARIABLE_REAL4:
-        num_points = LocalReduce_Count_REAL4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_REAL4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL8
       case CCTK_VARIABLE_REAL8:
-        num_points = LocalReduce_Count_REAL8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_REAL8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL16
       case CCTK_VARIABLE_REAL16:
-        num_points = LocalReduce_Count_REAL16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif  
       case CCTK_VARIABLE_COMPLEX:
-        num_points = LocalReduce_Count_COMPLEX(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_COMPLEX8
       case CCTK_VARIABLE_COMPLEX8:
-        num_points = LocalReduce_Count_COMPLEX8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX16
       case CCTK_VARIABLE_COMPLEX16:
-        num_points = LocalReduce_Count_COMPLEX16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX32
       case CCTK_VARIABLE_COMPLEX32:
-        num_points = LocalReduce_Count_COMPLEX32(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Count_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
     }
   }
 
+  /* Get the values of num_points and weight_sum */
+  ierr = Util_TableGetInt(param_table_handle, &num_points, "num_points");
   num_points--;
 
-  /* store the number of points in the paramater table */
-  if ( Util_TableQueryNKeys(param_table_handle) != 0)
+  /* store the number of points in the paramater table  and perform division */
+  ierr = Util_TableGetInt(param_table_handle, &global_calling, "global_calling");
+  if ( global_calling != 0)
   {
     ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
     ierr = Util_TableSetInt(param_table_handle, 3,"global_operation");
-    ierr = Util_TableSetInt(param_table_handle, 1,"perform_division");
   }
+
+  /* free memory */
+  free (iters_per_dim);
+  free (indices);
+  free (actual_indices);
+  free (actual_iters_per_dim);
+  free (input_array_offsets);
+  free (input_array_strides);
+  free (input_array_min_subscripts);
+  free (input_array_max_subscripts);
                                                                                 
   return (0);
 }
diff --git a/src/ReductionMax.c b/src/ReductionMax.c
index 8eb333c..e7143ee 100644
--- a/src/ReductionMax.c
+++ b/src/ReductionMax.c
@@ -137,6 +137,7 @@ static int ReductionMax (int N_dims, int operator_handle,
   int i, j, num_points;
   int ierr;
   int * iters_per_dim;
+  int global_calling = 0;
 
   /* indices to hold the temp indices of size N_dims  and iteration indices*/
   int * indices;
@@ -151,17 +152,12 @@ static int ReductionMax (int N_dims, int operator_handle,
   CCTK_INT * input_array_min_subscripts;
   CCTK_INT * input_array_max_subscripts;
 
-  /* excesion variables declared here */
-  int mask_on = 1;          /* mask is by default off=1 */
-  void * mask_array;        /* same dimensions/indexing as input arrays */
-  CCTK_INT mask_type_code;  /* one of the CCTK_VARIABLE_* codes */
-  CCTK_INT mask_offset;
-  CCTK_INT mask_time_level;
+  /* weight variables declared here */
+  int weight_on = 0;          /* weight is by default off=0 */
+  void const * weight;        /* pointer to the weight variable */  
+  CCTK_REAL weight_sum;
 
   /* prevent warnings for unused vars */
-  (void)(mask_array);
-  (void)(mask_offset + 0);
-  (void)(mask_time_level + 0);
   (void)(operator_handle + 0);
 
   /* set the number of points */
@@ -207,20 +203,16 @@ static int ReductionMax (int N_dims, int operator_handle,
               N_dims, input_array_max_subscripts, "input_array_max_subscripts");  
   }
 
-  /* for masks get values from param table (it they exist) */
+  /* for weights get values from param table (it they exist) */
   if ( Util_TableQueryNKeys(param_table_handle) != 0)
   {
     ierr = 0;
-    ierr = Util_TableGetInt(param_table_handle, &mask_type_code, "mask_type_code"); 
-
-     /*   mask_valid_min, mask_valid_max; 
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_min");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_max");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_array, "mask_array");  */ 
+    /* Get the weight_on parameter and the weight_var_index parameter */
+    ierr = Util_TableGetInt(param_table_handle, &weight_on, "weight_on");
+    ierr = Util_TableGetPointerToConst(param_table_handle, &weight, "weight");
+    /* Need to add more checking here for size, storage */
   }
+
   /* reduction maps an array to a single value of the same type */
   if (M_output_numbers != N_input_arrays)
   {
@@ -247,78 +239,80 @@ static int ReductionMax (int N_dims, int operator_handle,
     {
       /* in values type switches*/
       case CCTK_VARIABLE_BYTE:
-        num_points = LocalReduce_Max_BYTE(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_BYTE(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       case CCTK_VARIABLE_INT:
-        num_points = LocalReduce_Max_INT(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_INT(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_INT1
       case CCTK_VARIABLE_INT1:
-        num_points = LocalReduce_Max_INT1(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_INT1(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif                                                              
       #ifdef CCTK_INT2
       case CCTK_VARIABLE_INT2:
-        num_points = LocalReduce_Max_INT2(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_INT2(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT4
       case CCTK_VARIABLE_INT4:
-        num_points = LocalReduce_Max_INT4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_INT4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT8
       case CCTK_VARIABLE_INT8:
-        num_points = LocalReduce_Max_INT8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_INT8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;                                                                
       #endif
       case CCTK_VARIABLE_REAL:
-        num_points = LocalReduce_Max_REAL(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_REAL(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_REAL4
       case CCTK_VARIABLE_REAL4:
-        num_points = LocalReduce_Max_REAL4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_REAL4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL8
       case CCTK_VARIABLE_REAL8:
-        num_points = LocalReduce_Max_REAL8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_REAL8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL16
       case CCTK_VARIABLE_REAL16:
-        num_points = LocalReduce_Max_REAL16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif  
       case CCTK_VARIABLE_COMPLEX:
-        num_points = LocalReduce_Max_COMPLEX(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_COMPLEX8
       case CCTK_VARIABLE_COMPLEX8:
-        num_points = LocalReduce_Max_COMPLEX8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX16
       case CCTK_VARIABLE_COMPLEX16:
-        num_points = LocalReduce_Max_COMPLEX16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX32
       case CCTK_VARIABLE_COMPLEX32:
-        num_points = LocalReduce_Max_COMPLEX32(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Max_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
     }
   }
 
+  /* Get the values of num_points and weight_sum */
+  ierr = Util_TableGetInt(param_table_handle, &num_points, "num_points");
   num_points--;
   
-  /* store the number of points in the paramater table */
-  if ( Util_TableQueryNKeys(param_table_handle) != 0)
+  /* store the number of points in the paramater table  and perform division */
+  ierr = Util_TableGetInt(param_table_handle, &global_calling, "global_calling");
+  if ( global_calling != 0)
   {
     ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
     ierr = Util_TableSetInt(param_table_handle, 1,"global_operation");
-    ierr = Util_TableSetInt(param_table_handle, 1,"perform_division");
   }
 
   /* free memory */
diff --git a/src/ReductionMin.c b/src/ReductionMin.c
index f927e66..55512b2 100644
--- a/src/ReductionMin.c
+++ b/src/ReductionMin.c
@@ -138,6 +138,7 @@ static int ReductionMin (int N_dims, int operator_handle,
   int i, j, num_points;
   int ierr;
   int * iters_per_dim;
+  int global_calling = 0;
 
   /* indices to hold the temp indices of size N_dims  and iteration indices*/
   int * indices;
@@ -152,17 +153,12 @@ static int ReductionMin (int N_dims, int operator_handle,
   CCTK_INT * input_array_min_subscripts;
   CCTK_INT * input_array_max_subscripts;
 
-  /* excesion variables declared here */
-  int mask_on = 1;          /* mask is by default off=1 */
-  void * mask_array;        /* same dimensions/indexing as input arrays */
-  CCTK_INT mask_type_code;  /* one of the CCTK_VARIABLE_* codes */
-  CCTK_INT mask_offset;
-  CCTK_INT mask_time_level;
+  /* weight variables declared here */
+  int weight_on = 0;          /* weight is by default off=0 */
+  void const * weight;        /* pointer to the weight variable */  
+  CCTK_REAL weight_sum;
 
   /* prevent warnings for unused vars */
-  (void)(mask_array );
-  (void)(mask_offset + 0);
-  (void)(mask_time_level + 0);
   (void)(operator_handle + 0);
 
   /* set the number of points */
@@ -208,20 +204,16 @@ static int ReductionMin (int N_dims, int operator_handle,
              N_dims, input_array_max_subscripts, "input_array_max_subscripts");  
   }
 
-  /* for masks get values from param table (it they exist) */
+  /* for weights get values from param table (it they exist) */
   if ( Util_TableQueryNKeys(param_table_handle) != 0)
   {
     ierr = 0;
-    ierr = Util_TableGetInt(param_table_handle, &mask_type_code, "mask_type_code"); 
-
-     /*   mask_valid_min, mask_valid_max; 
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_min");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_max");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_array, "mask_array");  */ 
+    /* Get the weight_on parameter and the weight_var_index parameter */
+    ierr = Util_TableGetInt(param_table_handle, &weight_on, "weight_on");
+    ierr = Util_TableGetPointerToConst(param_table_handle, &weight, "weight");
+    /* Need to add more checking here for size, storage */
   }
+
   /* reduction maps an array to a single value of the same type */
   if (M_output_numbers != N_input_arrays)
   {
@@ -256,74 +248,79 @@ static int ReductionMin (int N_dims, int operator_handle,
     {
     /* in values type switches*/
       case CCTK_VARIABLE_BYTE:
-        num_points = LocalReduce_Min_BYTE(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_BYTE(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       case CCTK_VARIABLE_INT:
-        num_points = LocalReduce_Min_INT(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_INT(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_INT1
       case CCTK_VARIABLE_INT1:
-        num_points = LocalReduce_Min_INT1(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_INT1(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif                                                              
       #ifdef CCTK_INT2
       case CCTK_VARIABLE_INT2:
-        num_points = LocalReduce_Min_INT2(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_INT2(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT4
       case CCTK_VARIABLE_INT4:
-        num_points = LocalReduce_Min_INT4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_INT4(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT8
       case CCTK_VARIABLE_INT8:
-        num_points = LocalReduce_Min_INT8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_INT8(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;                                                                
       #endif
       case CCTK_VARIABLE_REAL:
-        num_points = LocalReduce_Min_REAL(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_REAL(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_REAL4
       case CCTK_VARIABLE_REAL4:
-        num_points = LocalReduce_Min_REAL4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_REAL4(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL8
       case CCTK_VARIABLE_REAL8:
-        num_points = LocalReduce_Min_REAL8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_REAL8(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL16
       case CCTK_VARIABLE_REAL16:
-        num_points = LocalReduce_Min_REAL16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_REAL16(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif  
       case CCTK_VARIABLE_COMPLEX:
-        num_points = LocalReduce_Min_COMPLEX(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_COMPLEX(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_COMPLEX8
       case CCTK_VARIABLE_COMPLEX8:
-        num_points = LocalReduce_Min_COMPLEX8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_COMPLEX8(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX16
       case CCTK_VARIABLE_COMPLEX16:
-        num_points = LocalReduce_Min_COMPLEX16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_COMPLEX16(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX32
       case CCTK_VARIABLE_COMPLEX32:
-        num_points = LocalReduce_Min_COMPLEX32(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Min_COMPLEX32(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
     }
   }
 
+  /* Get the values of num_points and weight_sum */
+  ierr = Util_TableGetInt(param_table_handle, &num_points, "num_points");
+  ierr = Util_TableGetReal(param_table_handle, &weight_sum, "weight_sum");
   num_points--;
 
-  /* store the number of points in the paramater table */
-  if ( Util_TableQueryNKeys(param_table_handle) != 0)
+
+  /* store the number of points in the paramater table  and perform division */
+  ierr = Util_TableGetInt(param_table_handle, &global_calling, "global_calling");
+  if ( global_calling != 0)
   {
     ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
     ierr = Util_TableSetInt(param_table_handle, 2,"global_operation");
diff --git a/src/ReductionNorm1.c b/src/ReductionNorm1.c
index 1b5eb3c..bc2fd02 100644
--- a/src/ReductionNorm1.c
+++ b/src/ReductionNorm1.c
@@ -152,17 +152,12 @@ static int ReductionL1 (int N_dims, int operator_handle,
   CCTK_INT * input_array_min_subscripts;
   CCTK_INT * input_array_max_subscripts;
 
-  /* excesion variables declared here */
-  int mask_on = 1;          /* mask is by default off=1 */
-  void * mask_array;        /* same dimensions/indexing as input arrays */
-  CCTK_INT mask_type_code;  /* one of the CCTK_VARIABLE_* codes */
-  CCTK_INT mask_offset;
-  CCTK_INT mask_time_level;
+  /* weight variables declared here */
+  int weight_on = 0;          /* weight is by default off=0 */
+  void const * weight;        /* pointer to the weight variable */  
+  CCTK_REAL weight_sum;
 
   /* prevent warnings for unused vars */
-  (void)(mask_array);
-  (void)(mask_offset + 0);
-  (void)(mask_time_level + 0);
   (void)(operator_handle + 0);
 
   /* set the number of points */
@@ -208,20 +203,16 @@ static int ReductionL1 (int N_dims, int operator_handle,
              N_dims, input_array_max_subscripts, "input_array_max_subscripts");  
   }
 
-  /* for masks get values from param table (it they exist) */
+  /* for weights get values from param table (it they exist) */
   if ( Util_TableQueryNKeys(param_table_handle) != 0)
   {
     ierr = 0;
-    ierr = Util_TableGetInt(param_table_handle, &mask_type_code, "mask_type_code"); 
-
-     /*   mask_valid_min, mask_valid_max; 
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_min");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_max");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_array, "mask_array");  */ 
+    /* Get the weight_on parameter and the weight_var_index parameter */
+    ierr = Util_TableGetInt(param_table_handle, &weight_on, "weight_on");
+    ierr = Util_TableGetPointerToConst(param_table_handle, &weight, "weight");
+    /* Need to add more checking here for size, storage */
   }
+
   /* reduction maps an array to a single value of the same type */
   if (M_output_numbers != N_input_arrays)
   {
@@ -260,70 +251,73 @@ static int ReductionL1 (int N_dims, int operator_handle,
     {
     /* in values type switches*/
       case CCTK_VARIABLE_BYTE:
-        num_points = LocalReduce_Norm1_BYTE(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_BYTE(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       case CCTK_VARIABLE_INT:
-        num_points = LocalReduce_Norm1_INT(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_INT(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_INT1
       case CCTK_VARIABLE_INT1:
-        num_points = LocalReduce_Norm1_INT1(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_INT1(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif                                                              
       #ifdef CCTK_INT2
       case CCTK_VARIABLE_INT2:
-        num_points = LocalReduce_Norm1_INT2(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_INT2(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT4
       case CCTK_VARIABLE_INT4:
-        num_points = LocalReduce_Norm1_INT4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_INT4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT8
       case CCTK_VARIABLE_INT8:
-        num_points = LocalReduce_Norm1_INT8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_INT8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;                                                                
       #endif
       case CCTK_VARIABLE_REAL:
-        num_points = LocalReduce_Norm1_REAL(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_REAL(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_REAL4
       case CCTK_VARIABLE_REAL4:
-        num_points = LocalReduce_Norm1_REAL4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_REAL4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL8
       case CCTK_VARIABLE_REAL8:
-        num_points = LocalReduce_Norm1_REAL8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_REAL8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL16
       case CCTK_VARIABLE_REAL16:
-        num_points = LocalReduce_Norm1_REAL16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif  
       case CCTK_VARIABLE_COMPLEX:
-        num_points = LocalReduce_Norm1_COMPLEX(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_COMPLEX8
       case CCTK_VARIABLE_COMPLEX8:
-        num_points = LocalReduce_Norm1_COMPLEX8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX16
       case CCTK_VARIABLE_COMPLEX16:
-        num_points = LocalReduce_Norm1_COMPLEX16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX32
       case CCTK_VARIABLE_COMPLEX32:
-        num_points = LocalReduce_Norm1_COMPLEX32(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm1_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
     }
   }
 
+  /* Get the values of num_points and weight_sum */
+  ierr = Util_TableGetInt(param_table_handle, &num_points, "num_points");
+  ierr = Util_TableGetReal(param_table_handle, &weight_sum, "weight_sum");
   num_points--;
 
   /* store the number of points in the paramater table  and perform division */
@@ -336,77 +330,164 @@ static int ReductionL1 (int N_dims, int operator_handle,
   }
   else
   {
-    for (i = 0; i< M_output_numbers; i++)
+    if (weight_on == 1)
+    {
+      if (ABS(weight_sum) > 1e-12)
+      {
+        for (i = 0; i< M_output_numbers; i++)
+        {
+          switch (output_number_type_codes[i])
+          {
+           /* out values type switches*/
+            case CCTK_VARIABLE_BYTE:
+              *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / weight_sum; 
+            break;
+            case CCTK_VARIABLE_INT:
+              *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / weight_sum; 
+            break;
+            #ifdef CCTK_INT1
+            case CCTK_VARIABLE_INT1:
+              *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif                                                              
+            #ifdef CCTK_INT2
+            case CCTK_VARIABLE_INT2:
+              *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_INT4
+            case CCTK_VARIABLE_INT4:
+              *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_INT8
+            case CCTK_VARIABLE_INT8:
+              *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / weight_sum; 
+            break;                                                                
+            #endif
+            case CCTK_VARIABLE_REAL:
+              *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / weight_sum; 
+            break;
+            #ifdef CCTK_REAL4
+            case CCTK_VARIABLE_REAL4:
+              *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_REAL8
+            case CCTK_VARIABLE_REAL8:
+              *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_REAL16
+            case CCTK_VARIABLE_REAL16:
+              *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            case CCTK_VARIABLE_COMPLEX:
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #ifdef CCTK_COMPLEX8
+            case CCTK_VARIABLE_COMPLEX8:
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX16
+            case CCTK_VARIABLE_COMPLEX16:
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; 
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX32
+            case CCTK_VARIABLE_COMPLEX32:
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #endif
+          }
+        }
+      }
+      else
+      {
+        CCTK_WARN (1, "The sum of weights in average reduction is zero");
+        return (-1);
+      }
+    }
+    else
     {
-      switch (output_number_type_codes[i])
+      for (i = 0; i< M_output_numbers; i++)
       {
-       /* out values type switches*/
-        case CCTK_VARIABLE_BYTE:
-          *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
-        break;
-        case CCTK_VARIABLE_INT:
-          *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
-        break;
-        #ifdef CCTK_INT1
-        case CCTK_VARIABLE_INT1:
-          *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
-        break;
-        #endif                                                              
-        #ifdef CCTK_INT2
-        case CCTK_VARIABLE_INT2:
-          *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_INT4
-        case CCTK_VARIABLE_INT4:
-          *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_INT8
-        case CCTK_VARIABLE_INT8:
-          *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
-        break;                                                                
-        #endif
-        case CCTK_VARIABLE_REAL:
-          *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
-        break;
-        #ifdef CCTK_REAL4
-        case CCTK_VARIABLE_REAL4:
-          *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_REAL8
-        case CCTK_VARIABLE_REAL8:
-          *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_REAL16
-        case CCTK_VARIABLE_REAL16:
-          *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        case CCTK_VARIABLE_COMPLEX:
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
-        break;
-        #ifdef CCTK_COMPLEX8
-        case CCTK_VARIABLE_COMPLEX8:
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX16
-        case CCTK_VARIABLE_COMPLEX16:
+        switch (output_number_type_codes[i])
+        {
+         /* out values type switches*/
+          case CCTK_VARIABLE_BYTE:
+            *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
+          break;
+          case CCTK_VARIABLE_INT:
+            *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
+          break;
+          #ifdef CCTK_INT1
+          case CCTK_VARIABLE_INT1:
+            *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
+          break;
+          #endif                                                              
+          #ifdef CCTK_INT2
+          case CCTK_VARIABLE_INT2:
+            *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_INT4
+          case CCTK_VARIABLE_INT4:
+            *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_INT8
+          case CCTK_VARIABLE_INT8:
+            *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
+          break;                                                                
+          #endif
+          case CCTK_VARIABLE_REAL:
+            *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
+          break;
+          #ifdef CCTK_REAL4
+          case CCTK_VARIABLE_REAL4:
+            *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_REAL8
+          case CCTK_VARIABLE_REAL8:
+            *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_REAL16
+          case CCTK_VARIABLE_REAL16:
+            *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          case CCTK_VARIABLE_COMPLEX:
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
+          break;
+          #ifdef CCTK_COMPLEX8
+          case CCTK_VARIABLE_COMPLEX8:
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX16
+          case CCTK_VARIABLE_COMPLEX16:
           (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
           (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX32
-        case CCTK_VARIABLE_COMPLEX32:
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
-        break;
-        #endif
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX32
+          case CCTK_VARIABLE_COMPLEX32:
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
+          break;
+          #endif
+        }
       }
     }
   }
diff --git a/src/ReductionNorm2.c b/src/ReductionNorm2.c
index 09d1ad3..36a0123 100644
--- a/src/ReductionNorm2.c
+++ b/src/ReductionNorm2.c
@@ -153,12 +153,10 @@ static int ReductionL2 (int N_dims, int operator_handle,
   CCTK_INT * input_array_min_subscripts;
   CCTK_INT * input_array_max_subscripts;
 
-  /* excesion variables declared here */
-  int mask_on = 1;          /* mask is by default off=1 */
-  void * mask_array;        /* same dimensions/indexing as input arrays */
-  CCTK_INT mask_type_code;  /* one of the CCTK_VARIABLE_* codes */
-  CCTK_INT mask_offset;
-  CCTK_INT mask_time_level;
+  /* weight variables declared here */
+  int weight_on = 0;          /* weight is by default off=0 */
+  void const * weight;        /* pointer to the weight variable */  
+  CCTK_REAL weight_sum;
 
   /* temporary complex variables*/
   CCTK_COMPLEX cmplx_tmp;
@@ -173,9 +171,6 @@ static int ReductionL2 (int N_dims, int operator_handle,
   #endif
   
   /* prevent warnings for unused vars */
-  (void)(mask_array);
-  (void)(mask_offset + 0);
-  (void)(mask_time_level + 0);
   (void)(operator_handle + 0);
 
   /* set the number of points */
@@ -221,20 +216,16 @@ static int ReductionL2 (int N_dims, int operator_handle,
              N_dims, input_array_max_subscripts, "input_array_max_subscripts");  
   }
 
-  /* for masks get values from param table (it they exist) */
+  /* for weights get values from param table (it they exist) */
   if ( Util_TableQueryNKeys(param_table_handle) != 0)
   {
     ierr = 0;
-    ierr = Util_TableGetInt(param_table_handle, &mask_type_code, "mask_type_code"); 
-
-     /*   mask_valid_min, mask_valid_max; 
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_min");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_max");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_array, "mask_array");  */ 
+    /* Get the weight_on parameter and the weight_var_index parameter */
+    ierr = Util_TableGetInt(param_table_handle, &weight_on, "weight_on");
+    ierr = Util_TableGetPointerToConst(param_table_handle, &weight, "weight");
+    /* Need to add more checking here for size, storage */
   }
+
   /* reduction maps an array to a single value of the same type */
   if (M_output_numbers != N_input_arrays)
   {
@@ -274,70 +265,73 @@ static int ReductionL2 (int N_dims, int operator_handle,
     {
     /* in values type switches*/
       case CCTK_VARIABLE_BYTE:
-        num_points = LocalReduce_Norm2_BYTE(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_BYTE(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       case CCTK_VARIABLE_INT:
-        num_points = LocalReduce_Norm2_INT(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_INT(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_INT1
       case CCTK_VARIABLE_INT1:
-        num_points = LocalReduce_Norm2_INT1(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_INT1(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif                                                              
       #ifdef CCTK_INT2
       case CCTK_VARIABLE_INT2:
-        num_points = LocalReduce_Norm2_INT2(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_INT2(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT4
       case CCTK_VARIABLE_INT4:
-        num_points = LocalReduce_Norm2_INT4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_INT4(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT8
       case CCTK_VARIABLE_INT8:
-        num_points = LocalReduce_Norm2_INT8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_INT8(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;                                                                
       #endif
       case CCTK_VARIABLE_REAL:
-        num_points = LocalReduce_Norm2_REAL(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_REAL(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_REAL4
       case CCTK_VARIABLE_REAL4:
-        num_points = LocalReduce_Norm2_REAL4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_REAL4(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL8
       case CCTK_VARIABLE_REAL8:
-        num_points = LocalReduce_Norm2_REAL8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_REAL8(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL16
       case CCTK_VARIABLE_REAL16:
-        num_points = LocalReduce_Norm2_REAL16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_REAL16(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif  
       case CCTK_VARIABLE_COMPLEX:
-        num_points = LocalReduce_Norm2_COMPLEX(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_COMPLEX(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_COMPLEX8
       case CCTK_VARIABLE_COMPLEX8:
-        num_points = LocalReduce_Norm2_COMPLEX8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_COMPLEX8(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX16
       case CCTK_VARIABLE_COMPLEX16:
-        num_points = LocalReduce_Norm2_COMPLEX16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_COMPLEX16(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX32
       case CCTK_VARIABLE_COMPLEX32:
-        num_points = LocalReduce_Norm2_COMPLEX32(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Norm2_COMPLEX32(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
     }
   }
 
+  /* Get the values of num_points and weight_sum */
+  ierr = Util_TableGetInt(param_table_handle, &num_points, "num_points");
+  ierr = Util_TableGetReal(param_table_handle, &weight_sum, "weight_sum");
   num_points--;
 
   /* store the number of points in the paramater table  and perform division */
@@ -351,107 +345,224 @@ static int ReductionL2 (int N_dims, int operator_handle,
   }
   else
   {
-    for (i = 0; i< M_output_numbers; i++)
+    if (weight_on == 1)
+    {
+      if (ABS(weight_sum) > 1e-12)
+      {
+        for (i = 0; i< M_output_numbers; i++)
+        {
+          switch (output_number_type_codes[i])
+          {
+          /* out values type switches*/
+            case CCTK_VARIABLE_BYTE:
+              *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_BYTE *) output_numbers[i]) = sqrt(*( (CCTK_BYTE *) output_numbers[i])); 
+            break;
+            case CCTK_VARIABLE_INT:
+              *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_INT *) output_numbers[i]) = sqrt( *( (CCTK_INT *) output_numbers[i])); 
+            break;
+            #ifdef CCTK_INT1
+            case CCTK_VARIABLE_INT1:
+              *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_INT1 *) output_numbers[i]) = sqrt(*( (CCTK_INT1 *) output_numbers[i])); 
+            break;
+            #endif                                                              
+            #ifdef CCTK_INT2
+            case CCTK_VARIABLE_INT2:
+              *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_INT2 *) output_numbers[i]) = sqrt(*( (CCTK_INT2 *) output_numbers[i])); 
+            break;
+            #endif
+            #ifdef CCTK_INT4
+            case CCTK_VARIABLE_INT4:
+              *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_INT4 *) output_numbers[i]) = sqrt( *( (CCTK_INT4 *) output_numbers[i])); 
+            break;
+            #endif
+            #ifdef CCTK_INT8
+            case CCTK_VARIABLE_INT8:
+              *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_INT8 *) output_numbers[i]) = sqrt(*( (CCTK_INT8 *) output_numbers[i])); 
+            break;                                                                
+            #endif
+            case CCTK_VARIABLE_REAL:
+              *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_REAL *) output_numbers[i]) = sqrt(*( (CCTK_REAL *) output_numbers[i])); 
+            break;
+            #ifdef CCTK_REAL4
+            case CCTK_VARIABLE_REAL4:
+              *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_REAL4 *) output_numbers[i]) = sqrt(*( (CCTK_REAL4 *) output_numbers[i])); 
+            break;
+            #endif
+            #ifdef CCTK_REAL8
+            case CCTK_VARIABLE_REAL8:
+              *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_REAL8 *) output_numbers[i]) = sqrt(*( (CCTK_REAL8 *) output_numbers[i])); 
+            break;
+            #endif
+            #ifdef CCTK_REAL16
+            case CCTK_VARIABLE_REAL16:
+              *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_REAL16 *) output_numbers[i]) = sqrt(*( (CCTK_REAL16 *) output_numbers[i]));         
+            break;
+            #endif
+            case CCTK_VARIABLE_COMPLEX:
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; 
+              cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re;
+              cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re;
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im;
+            break;
+            #ifdef CCTK_COMPLEX8
+            case CCTK_VARIABLE_COMPLEX8:
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; 
+              cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re;
+              cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re;
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im;
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX16
+            case CCTK_VARIABLE_COMPLEX16:
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; 
+              cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re;
+              cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re;
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im;
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX32
+            case CCTK_VARIABLE_COMPLEX32:
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; 
+              cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re;
+              cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re;
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im;
+            break;
+            #endif
+          }
+        }
+      }
+      else
+      {
+        CCTK_WARN (1, "The sum of weights in average reduction is zero");
+        return (-1);
+      }
+    }
+    else
     {
-      switch (output_number_type_codes[i])
+      for (i = 0; i< M_output_numbers; i++)
       {
-       /* out values type switches*/
-        case CCTK_VARIABLE_BYTE:
-          *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
-          *( (CCTK_BYTE *) output_numbers[i]) = sqrt(*( (CCTK_BYTE *) output_numbers[i])); 
-        break;
-        case CCTK_VARIABLE_INT:
-          *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT *) output_numbers[i]) = sqrt( *( (CCTK_INT *) output_numbers[i])); 
-        break;
-        #ifdef CCTK_INT1
-        case CCTK_VARIABLE_INT1:
-          *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT1 *) output_numbers[i]) = sqrt(*( (CCTK_INT1 *) output_numbers[i])); 
-        break;
-        #endif                                                              
-        #ifdef CCTK_INT2
-        case CCTK_VARIABLE_INT2:
-          *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT2 *) output_numbers[i]) = sqrt(*( (CCTK_INT2 *) output_numbers[i])); 
-        break;
-        #endif
-        #ifdef CCTK_INT4
-        case CCTK_VARIABLE_INT4:
-          *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT4 *) output_numbers[i]) = sqrt( *( (CCTK_INT4 *) output_numbers[i])); 
-        break;
-        #endif
-        #ifdef CCTK_INT8
-        case CCTK_VARIABLE_INT8:
-          *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT8 *) output_numbers[i]) = sqrt(*( (CCTK_INT8 *) output_numbers[i])); 
-        break;                                                                
-        #endif
-        case CCTK_VARIABLE_REAL:
-          *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL *) output_numbers[i]) = sqrt(*( (CCTK_REAL *) output_numbers[i])); 
-        break;
-        #ifdef CCTK_REAL4
-        case CCTK_VARIABLE_REAL4:
-          *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL4 *) output_numbers[i]) = sqrt(*( (CCTK_REAL4 *) output_numbers[i])); 
-        break;
-        #endif
-        #ifdef CCTK_REAL8
-        case CCTK_VARIABLE_REAL8:
-          *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL8 *) output_numbers[i]) = sqrt(*( (CCTK_REAL8 *) output_numbers[i])); 
-        break;
-        #endif
-        #ifdef CCTK_REAL16
-        case CCTK_VARIABLE_REAL16:
-          *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL16 *) output_numbers[i]) = sqrt(*( (CCTK_REAL16 *) output_numbers[i]));         
-        break;
-        #endif
-        case CCTK_VARIABLE_COMPLEX:
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re;
-          cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re;
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im;
-        break;
-        #ifdef CCTK_COMPLEX8
-        case CCTK_VARIABLE_COMPLEX8:
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re;
-          cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re;
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im;
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX16
-        case CCTK_VARIABLE_COMPLEX16:
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re;
-          cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re;
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im;
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX32
-        case CCTK_VARIABLE_COMPLEX32:
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re;
-          cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re;
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im;
-        break;
-        #endif
+        switch (output_number_type_codes[i])
+        {
+         /* out values type switches*/
+          case CCTK_VARIABLE_BYTE:
+            *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
+            *( (CCTK_BYTE *) output_numbers[i]) = sqrt(*( (CCTK_BYTE *) output_numbers[i])); 
+          break;
+          case CCTK_VARIABLE_INT:
+            *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT *) output_numbers[i]) = sqrt( *( (CCTK_INT *) output_numbers[i])); 
+          break;
+          #ifdef CCTK_INT1
+          case CCTK_VARIABLE_INT1:
+            *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT1 *) output_numbers[i]) = sqrt(*( (CCTK_INT1 *) output_numbers[i])); 
+          break;
+          #endif                                                              
+          #ifdef CCTK_INT2
+          case CCTK_VARIABLE_INT2:
+            *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT2 *) output_numbers[i]) = sqrt(*( (CCTK_INT2 *) output_numbers[i])); 
+          break;
+          #endif
+          #ifdef CCTK_INT4
+          case CCTK_VARIABLE_INT4:
+            *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT4 *) output_numbers[i]) = sqrt( *( (CCTK_INT4 *) output_numbers[i])); 
+          break;
+          #endif
+          #ifdef CCTK_INT8
+          case CCTK_VARIABLE_INT8:
+            *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT8 *) output_numbers[i]) = sqrt(*( (CCTK_INT8 *) output_numbers[i])); 
+          break;                                                                
+          #endif
+          case CCTK_VARIABLE_REAL:
+            *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL *) output_numbers[i]) = sqrt(*( (CCTK_REAL *) output_numbers[i])); 
+          break;
+          #ifdef CCTK_REAL4
+          case CCTK_VARIABLE_REAL4:
+            *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL4 *) output_numbers[i]) = sqrt(*( (CCTK_REAL4 *) output_numbers[i])); 
+          break;
+          #endif
+          #ifdef CCTK_REAL8
+          case CCTK_VARIABLE_REAL8:
+            *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL8 *) output_numbers[i]) = sqrt(*( (CCTK_REAL8 *) output_numbers[i])); 
+          break;
+          #endif
+          #ifdef CCTK_REAL16
+          case CCTK_VARIABLE_REAL16:
+            *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL16 *) output_numbers[i]) = sqrt(*( (CCTK_REAL16 *) output_numbers[i]));         
+          break;
+          #endif
+          case CCTK_VARIABLE_COMPLEX:
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re;
+            cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re;
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im;
+          break;
+          #ifdef CCTK_COMPLEX8
+          case CCTK_VARIABLE_COMPLEX8:
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re;
+            cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re;
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im;
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX16
+          case CCTK_VARIABLE_COMPLEX16:
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re;
+            cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re;
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im;
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX32
+          case CCTK_VARIABLE_COMPLEX32:
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re;
+            cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/2.0);
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re;
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im;
+          break;
+          #endif
+        }
       }
     }
   }
diff --git a/src/ReductionNorm3.c b/src/ReductionNorm3.c
index aea77bc..5c2ccf7 100644
--- a/src/ReductionNorm3.c
+++ b/src/ReductionNorm3.c
@@ -153,12 +153,10 @@ static int ReductionL3 (int N_dims, int operator_handle,
   CCTK_INT * input_array_min_subscripts;
   CCTK_INT * input_array_max_subscripts;
 
-  /* excesion variables declared here */
-  int mask_on = 1;          /* mask is by default off=1 */
-  void * mask_array;        /* same dimensions/indexing as input arrays */
-  CCTK_INT mask_type_code;  /* one of the CCTK_VARIABLE_* codes */
-  CCTK_INT mask_offset;
-  CCTK_INT mask_time_level;
+  /* weight variables declared here */
+  int weight_on = 0;          /* weight is by default off=0 */
+  void const * weight;        /* pointer to the weight variable */  
+  CCTK_REAL weight_sum;
 
   /* temporary complex variables*/
   CCTK_COMPLEX cmplx_tmp;
@@ -173,9 +171,6 @@ static int ReductionL3 (int N_dims, int operator_handle,
   #endif
   
   /* prevent warnings for unused vars */
-  (void)(mask_array);
-  (void)(mask_offset + 0);
-  (void)(mask_time_level + 0);
   (void)(operator_handle + 0);
 
   /* set the number of points */
@@ -221,20 +216,16 @@ static int ReductionL3 (int N_dims, int operator_handle,
              N_dims, input_array_max_subscripts, "input_array_max_subscripts");  
   }
 
-  /* for masks get values from param table (it they exist) */
+  /* for weights get values from param table (it they exist) */
   if ( Util_TableQueryNKeys(param_table_handle) != 0)
   {
     ierr = 0;
-    ierr = Util_TableGetInt(param_table_handle, &mask_type_code, "mask_type_code"); 
-
-     /*   mask_valid_min, mask_valid_max; 
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_min");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_max");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_array, "mask_array");  */ 
+    /* Get the weight_on parameter and the weight_var_index parameter */
+    ierr = Util_TableGetInt(param_table_handle, &weight_on, "weight_on");
+    ierr = Util_TableGetPointerToConst(param_table_handle, &weight, "weight");
+    /* Need to add more checking here for size, storage */
   }
+
   /* reduction maps an array to a single value of the same type */
   if (M_output_numbers != N_input_arrays)
   {
@@ -271,70 +262,73 @@ static int ReductionL3 (int N_dims, int operator_handle,
     {
     /* in values type switches*/
       case CCTK_VARIABLE_BYTE:
-        num_points = LocalReduce_Norm3_BYTE(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_BYTE(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       case CCTK_VARIABLE_INT:
-        num_points = LocalReduce_Norm3_INT(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_INT(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_INT1
       case CCTK_VARIABLE_INT1:
-        num_points = LocalReduce_Norm3_INT1(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_INT1(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif                                                              
       #ifdef CCTK_INT2
       case CCTK_VARIABLE_INT2:
-        num_points = LocalReduce_Norm3_INT2(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_INT2(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT4
       case CCTK_VARIABLE_INT4:
-        num_points = LocalReduce_Norm3_INT4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_INT4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT8
       case CCTK_VARIABLE_INT8:
-        num_points = LocalReduce_Norm3_INT8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_INT8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;                                                                
       #endif
       case CCTK_VARIABLE_REAL:
-        num_points = LocalReduce_Norm3_REAL(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_REAL(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_REAL4
       case CCTK_VARIABLE_REAL4:
-        num_points = LocalReduce_Norm3_REAL4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_REAL4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL8
       case CCTK_VARIABLE_REAL8:
-        num_points = LocalReduce_Norm3_REAL8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_REAL8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL16
       case CCTK_VARIABLE_REAL16:
-        num_points = LocalReduce_Norm3_REAL16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif  
       case CCTK_VARIABLE_COMPLEX:
-        num_points = LocalReduce_Norm3_COMPLEX(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_COMPLEX8
       case CCTK_VARIABLE_COMPLEX8:
-        num_points = LocalReduce_Norm3_COMPLEX8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX16
       case CCTK_VARIABLE_COMPLEX16:
-        num_points = LocalReduce_Norm3_COMPLEX16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX32
       case CCTK_VARIABLE_COMPLEX32:
-        num_points = LocalReduce_Norm3_COMPLEX32(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm3_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
     }
   }
 
+  /* Get the values of num_points and weight_sum */
+  ierr = Util_TableGetInt(param_table_handle, &num_points, "num_points");
+  ierr = Util_TableGetReal(param_table_handle, &weight_sum, "weight_sum");
   num_points--;
 
   /* store the number of points in the paramater table  and perform division */
@@ -348,107 +342,224 @@ static int ReductionL3 (int N_dims, int operator_handle,
   }
   else
   {
-    for (i = 0; i< M_output_numbers; i++)
+    if (weight_on == 1)
+    {
+      if (ABS(weight_sum) > 1e-12)
+      {
+        for (i = 0; i< M_output_numbers; i++)
+        {
+          switch (output_number_type_codes[i])
+          {
+            /* out values type switches*/
+            case CCTK_VARIABLE_BYTE:
+              *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
+              *( (CCTK_BYTE *) output_numbers[i]) = pow(*( (CCTK_BYTE *) output_numbers[i]), 1.0/3.0); 
+            break;
+            case CCTK_VARIABLE_INT:
+              *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
+              *( (CCTK_INT *) output_numbers[i]) = pow(*( (CCTK_INT *) output_numbers[i]), 1.0/3.0); 
+            break;
+            #ifdef CCTK_INT1
+            case CCTK_VARIABLE_INT1:
+              *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
+              *( (CCTK_INT1 *) output_numbers[i]) = pow(*( (CCTK_INT1 *) output_numbers[i]), 1.0/3.0); 
+            break;
+            #endif                                                              
+            #ifdef CCTK_INT2
+            case CCTK_VARIABLE_INT2:
+              *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
+              *( (CCTK_INT2 *) output_numbers[i]) = pow(*( (CCTK_INT2 *) output_numbers[i]), 1.0/3.0); 
+            break;
+            #endif
+            #ifdef CCTK_INT4
+            case CCTK_VARIABLE_INT4:
+              *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
+              *( (CCTK_INT4 *) output_numbers[i]) = pow( *( (CCTK_INT4 *) output_numbers[i]), 1.0/3.0); 
+            break;
+            #endif
+            #ifdef CCTK_INT8
+            case CCTK_VARIABLE_INT8:
+              *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
+              *( (CCTK_INT8 *) output_numbers[i]) = pow(*( (CCTK_INT8 *) output_numbers[i]), 1.0/3.0); 
+            break;                                                                
+            #endif
+            case CCTK_VARIABLE_REAL:
+              *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
+              *( (CCTK_REAL *) output_numbers[i]) = pow(*( (CCTK_REAL *) output_numbers[i]), 1.0/3.0); 
+            break;
+            #ifdef CCTK_REAL4
+            case CCTK_VARIABLE_REAL4:
+              *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
+              *( (CCTK_REAL4 *) output_numbers[i]) = pow(*( (CCTK_REAL4 *) output_numbers[i]), 1.0/3.0); 
+            break;
+            #endif
+            #ifdef CCTK_REAL8
+            case CCTK_VARIABLE_REAL8:
+              *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
+              *( (CCTK_REAL8 *) output_numbers[i]) = pow(*( (CCTK_REAL8 *) output_numbers[i]), 1.0/3.0); 
+            break;
+            #endif
+            #ifdef CCTK_REAL16
+            case CCTK_VARIABLE_REAL16:
+              *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
+              *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/3.0); 
+            break;
+            #endif
+            case CCTK_VARIABLE_COMPLEX:
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
+              cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re;
+              cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re;
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im;
+            break;
+            #ifdef CCTK_COMPLEX8
+            case CCTK_VARIABLE_COMPLEX8:
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
+              cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re;
+              cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re;
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im;
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX16
+            case CCTK_VARIABLE_COMPLEX16:
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; 
+              cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re;
+              cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re;
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im;
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX32
+            case CCTK_VARIABLE_COMPLEX32:
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
+              cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re;
+              cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re;
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im;
+            break;
+            #endif
+          }
+        }
+      } 
+      else
+      {
+        CCTK_WARN (1, "The sum of weights in average reduction is zero");
+        return (-1);
+      }
+    }
+    else
     {
-      switch (output_number_type_codes[i])
+      for (i = 0; i< M_output_numbers; i++)
       {
-       /* out values type switches*/
-        case CCTK_VARIABLE_BYTE:
-          *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
-          *( (CCTK_BYTE *) output_numbers[i]) = pow(*( (CCTK_BYTE *) output_numbers[i]), 1.0/3.0); 
-        break;
-        case CCTK_VARIABLE_INT:
-          *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT *) output_numbers[i]) = pow(*( (CCTK_INT *) output_numbers[i]), 1.0/3.0); 
-        break;
-        #ifdef CCTK_INT1
-        case CCTK_VARIABLE_INT1:
-          *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT1 *) output_numbers[i]) = pow(*( (CCTK_INT1 *) output_numbers[i]), 1.0/3.0); 
-        break;
-        #endif                                                              
-        #ifdef CCTK_INT2
-        case CCTK_VARIABLE_INT2:
-          *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT2 *) output_numbers[i]) = pow(*( (CCTK_INT2 *) output_numbers[i]), 1.0/3.0); 
-        break;
-        #endif
-        #ifdef CCTK_INT4
-        case CCTK_VARIABLE_INT4:
-          *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT4 *) output_numbers[i]) = pow( *( (CCTK_INT4 *) output_numbers[i]), 1.0/3.0); 
-        break;
-        #endif
-        #ifdef CCTK_INT8
-        case CCTK_VARIABLE_INT8:
-          *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT8 *) output_numbers[i]) = pow(*( (CCTK_INT8 *) output_numbers[i]), 1.0/3.0); 
-        break;                                                                
-        #endif
-        case CCTK_VARIABLE_REAL:
-          *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL *) output_numbers[i]) = pow(*( (CCTK_REAL *) output_numbers[i]), 1.0/3.0); 
-        break;
-        #ifdef CCTK_REAL4
-        case CCTK_VARIABLE_REAL4:
-          *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL4 *) output_numbers[i]) = pow(*( (CCTK_REAL4 *) output_numbers[i]), 1.0/3.0); 
-        break;
-        #endif
-        #ifdef CCTK_REAL8
-        case CCTK_VARIABLE_REAL8:
-          *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL8 *) output_numbers[i]) = pow(*( (CCTK_REAL8 *) output_numbers[i]), 1.0/3.0); 
-        break;
-        #endif
-        #ifdef CCTK_REAL16
-        case CCTK_VARIABLE_REAL16:
-          *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/3.0); 
-        break;
-        #endif
-        case CCTK_VARIABLE_COMPLEX:
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re;
-          cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re;
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im;
-        break;
-        #ifdef CCTK_COMPLEX8
-        case CCTK_VARIABLE_COMPLEX8:
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re;
-          cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re;
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im;
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX16
-        case CCTK_VARIABLE_COMPLEX16:
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re;
-          cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re;
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im;
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX32
-        case CCTK_VARIABLE_COMPLEX32:
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re;
-          cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re;
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im;
-        break;
-        #endif
+        switch (output_number_type_codes[i])
+        {
+          /* out values type switches*/
+          case CCTK_VARIABLE_BYTE:
+            *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
+            *( (CCTK_BYTE *) output_numbers[i]) = pow(*( (CCTK_BYTE *) output_numbers[i]), 1.0/3.0); 
+          break;
+          case CCTK_VARIABLE_INT:
+            *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT *) output_numbers[i]) = pow(*( (CCTK_INT *) output_numbers[i]), 1.0/3.0); 
+          break;
+          #ifdef CCTK_INT1
+          case CCTK_VARIABLE_INT1:
+            *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT1 *) output_numbers[i]) = pow(*( (CCTK_INT1 *) output_numbers[i]), 1.0/3.0); 
+          break;
+          #endif                                                              
+          #ifdef CCTK_INT2
+          case CCTK_VARIABLE_INT2:
+            *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT2 *) output_numbers[i]) = pow(*( (CCTK_INT2 *) output_numbers[i]), 1.0/3.0); 
+          break;
+          #endif
+          #ifdef CCTK_INT4
+          case CCTK_VARIABLE_INT4:
+            *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT4 *) output_numbers[i]) = pow( *( (CCTK_INT4 *) output_numbers[i]), 1.0/3.0); 
+          break;
+          #endif
+          #ifdef CCTK_INT8
+          case CCTK_VARIABLE_INT8:
+            *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT8 *) output_numbers[i]) = pow(*( (CCTK_INT8 *) output_numbers[i]), 1.0/3.0); 
+          break;                                                                
+          #endif
+          case CCTK_VARIABLE_REAL:
+            *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL *) output_numbers[i]) = pow(*( (CCTK_REAL *) output_numbers[i]), 1.0/3.0); 
+          break;
+          #ifdef CCTK_REAL4
+          case CCTK_VARIABLE_REAL4:
+            *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL4 *) output_numbers[i]) = pow(*( (CCTK_REAL4 *) output_numbers[i]), 1.0/3.0); 
+          break;
+          #endif
+          #ifdef CCTK_REAL8
+          case CCTK_VARIABLE_REAL8:
+            *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL8 *) output_numbers[i]) = pow(*( (CCTK_REAL8 *) output_numbers[i]), 1.0/3.0); 
+          break;
+          #endif
+          #ifdef CCTK_REAL16
+          case CCTK_VARIABLE_REAL16:
+            *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/3.0); 
+          break;
+          #endif
+          case CCTK_VARIABLE_COMPLEX:
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re;
+            cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re;
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im;
+          break;
+          #ifdef CCTK_COMPLEX8
+          case CCTK_VARIABLE_COMPLEX8:
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re;
+            cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re;
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im;
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX16
+          case CCTK_VARIABLE_COMPLEX16:
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re;
+            cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re;
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im;
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX32
+          case CCTK_VARIABLE_COMPLEX32:
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re;
+            cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/3.0);
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re;
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im;
+          break;
+          #endif
+        }
       }
     }
   }
diff --git a/src/ReductionNorm4.c b/src/ReductionNorm4.c
index b72df97..c945555 100644
--- a/src/ReductionNorm4.c
+++ b/src/ReductionNorm4.c
@@ -153,12 +153,10 @@ static int ReductionL4 (int N_dims, int operator_handle,
   CCTK_INT * input_array_min_subscripts;
   CCTK_INT * input_array_max_subscripts;
 
-  /* excesion variables declared here */
-  int mask_on = 1;          /* mask is by default off=1 */
-  void * mask_array;        /* same dimensions/indexing as input arrays */
-  CCTK_INT mask_type_code;  /* one of the CCTK_VARIABLE_* codes */
-  CCTK_INT mask_offset;
-  CCTK_INT mask_time_level;
+  /* weight variables declared here */
+  int weight_on = 0;          /* weight is by default off=0 */
+  void const * weight;        /* pointer to the weight variable */  
+  CCTK_REAL weight_sum;
   
   /* temporary complex variables*/
   CCTK_COMPLEX cmplx_tmp;
@@ -173,9 +171,6 @@ static int ReductionL4 (int N_dims, int operator_handle,
   #endif
   
   /* prevent warnings for unused vars */
-  (void)(mask_array);
-  (void)(mask_offset + 0);
-  (void)(mask_time_level + 0);
   (void)(operator_handle + 0);
 
   /* set the number of points */
@@ -221,20 +216,16 @@ static int ReductionL4 (int N_dims, int operator_handle,
              N_dims, input_array_max_subscripts, "input_array_max_subscripts");  
   }
 
-  /* for masks get values from param table (it they exist) */
+  /* for weights get values from param table (it they exist) */
   if ( Util_TableQueryNKeys(param_table_handle) != 0)
   {
     ierr = 0;
-    ierr = Util_TableGetInt(param_table_handle, &mask_type_code, "mask_type_code"); 
-
-     /*   mask_valid_min, mask_valid_max; 
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_min");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_max");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_array, "mask_array");  */ 
+    /* Get the weight_on parameter and the weight_var_index parameter */
+    ierr = Util_TableGetInt(param_table_handle, &weight_on, "weight_on");
+    ierr = Util_TableGetPointerToConst(param_table_handle, &weight, "weight");
+    /* Need to add more checking here for size, storage */
   }
+
   /* reduction maps an array to a single value of the same type */
   if (M_output_numbers != N_input_arrays)
   {
@@ -271,70 +262,73 @@ static int ReductionL4 (int N_dims, int operator_handle,
     {
     /* in values type switches*/
       case CCTK_VARIABLE_BYTE:
-        num_points = LocalReduce_Norm4_BYTE(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_BYTE(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       case CCTK_VARIABLE_INT:
-        num_points = LocalReduce_Norm4_INT(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_INT(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_INT1
       case CCTK_VARIABLE_INT1:
-        num_points = LocalReduce_Norm4_INT1(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_INT1(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif                                                              
       #ifdef CCTK_INT2
       case CCTK_VARIABLE_INT2:
-        num_points = LocalReduce_Norm4_INT2(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_INT2(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT4
       case CCTK_VARIABLE_INT4:
-        num_points = LocalReduce_Norm4_INT4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_INT4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT8
       case CCTK_VARIABLE_INT8:
-        num_points = LocalReduce_Norm4_INT8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_INT8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;                                                                
       #endif
       case CCTK_VARIABLE_REAL:
-        num_points = LocalReduce_Norm4_REAL(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_REAL(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_REAL4
       case CCTK_VARIABLE_REAL4:
-        num_points = LocalReduce_Norm4_REAL4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_REAL4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL8
       case CCTK_VARIABLE_REAL8:
-        num_points = LocalReduce_Norm4_REAL8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_REAL8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL16
       case CCTK_VARIABLE_REAL16:
-        num_points = LocalReduce_Norm4_REAL16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif  
       case CCTK_VARIABLE_COMPLEX:
-        num_points = LocalReduce_Norm4_COMPLEX(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_COMPLEX8
       case CCTK_VARIABLE_COMPLEX8:
-        num_points = LocalReduce_Norm4_COMPLEX8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX16
       case CCTK_VARIABLE_COMPLEX16:
-        num_points = LocalReduce_Norm4_COMPLEX16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX32
       case CCTK_VARIABLE_COMPLEX32:
-        num_points = LocalReduce_Norm4_COMPLEX32(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_Norm4_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
     }
   }
 
+  /* Get the values of num_points and weight_sum */
+  ierr = Util_TableGetInt(param_table_handle, &num_points, "num_points");
+  ierr = Util_TableGetReal(param_table_handle, &weight_sum, "weight_sum");
   num_points--;
 
   /* store the number of points in the paramater table  and perform division */
@@ -348,107 +342,224 @@ static int ReductionL4 (int N_dims, int operator_handle,
   }
   else
   {
-    for (i = 0; i< M_output_numbers; i++)
+    if (weight_on == 1)
+    {
+      if (ABS(weight_sum) > 1e-12)
+      {
+        for (i = 0; i< M_output_numbers; i++)
+        {
+          switch (output_number_type_codes[i])
+          {
+            /* out values type switches*/
+            case CCTK_VARIABLE_BYTE:
+              *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_BYTE *) output_numbers[i]) = pow(*( (CCTK_BYTE *) output_numbers[i]), 1.0/4.0); 
+            break;
+            case CCTK_VARIABLE_INT:
+              *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_INT *) output_numbers[i]) = pow(*( (CCTK_INT *) output_numbers[i]), 1.0/4.0); 
+            break;
+            #ifdef CCTK_INT1
+            case CCTK_VARIABLE_INT1:
+              *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_INT1 *) output_numbers[i]) = pow(*( (CCTK_INT1 *) output_numbers[i]), 1.0/4.0); 
+            break;
+            #endif                                                              
+            #ifdef CCTK_INT2
+            case CCTK_VARIABLE_INT2:
+              *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_INT2 *) output_numbers[i]) = pow(*( (CCTK_INT2 *) output_numbers[i]), 1.0/4.0); 
+            break;
+            #endif
+            #ifdef CCTK_INT4
+            case CCTK_VARIABLE_INT4:
+              *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_INT4 *) output_numbers[i]) = pow( *( (CCTK_INT4 *) output_numbers[i]), 1.0/4.0); 
+            break;
+            #endif
+            #ifdef CCTK_INT8
+            case CCTK_VARIABLE_INT8:
+              *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_INT8 *) output_numbers[i]) = pow(*( (CCTK_INT8 *) output_numbers[i]), 1.0/4.0); 
+            break;                                                                
+            #endif
+            case CCTK_VARIABLE_REAL:
+              *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_REAL *) output_numbers[i]) = pow(*( (CCTK_REAL *) output_numbers[i]), 1.0/4.0); 
+            break;
+            #ifdef CCTK_REAL4
+            case CCTK_VARIABLE_REAL4:
+              *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_REAL4 *) output_numbers[i]) = pow(*( (CCTK_REAL4 *) output_numbers[i]), 1.0/4.0); 
+            break;
+            #endif
+            #ifdef CCTK_REAL8
+            case CCTK_VARIABLE_REAL8:
+              *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_REAL8 *) output_numbers[i]) = pow(*( (CCTK_REAL8 *) output_numbers[i]), 1.0/4.0); 
+            break;
+            #endif
+            #ifdef CCTK_REAL16
+            case CCTK_VARIABLE_REAL16:
+              *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; 
+              *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/4.0); 
+            break;
+            #endif
+            case CCTK_VARIABLE_COMPLEX:
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; 
+              cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re;
+              cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re;
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im;
+            break;
+            #ifdef CCTK_COMPLEX8
+            case CCTK_VARIABLE_COMPLEX8:
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; 
+              cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re;
+              cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re;
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im;
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX16
+            case CCTK_VARIABLE_COMPLEX16:
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum;
+              cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re;
+              cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re;
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im;
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX32
+            case CCTK_VARIABLE_COMPLEX32:
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; 
+              cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re;
+              cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im;
+              cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re;
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im;
+            break;
+            #endif
+          }
+        }
+      }
+      else
+      {
+        CCTK_WARN (1, "The sum of weights in average reduction is zero");
+        return (-1);
+      }
+    }
+    else
     {
-      switch (output_number_type_codes[i])
+      for (i = 0; i< M_output_numbers; i++)
       {
-       /* out values type switches*/
-        case CCTK_VARIABLE_BYTE:
-          *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
-          *( (CCTK_BYTE *) output_numbers[i]) = pow(*( (CCTK_BYTE *) output_numbers[i]), 1.0/4.0); 
-        break;
-        case CCTK_VARIABLE_INT:
-          *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT *) output_numbers[i]) = pow(*( (CCTK_INT *) output_numbers[i]), 1.0/4.0); 
-        break;
-        #ifdef CCTK_INT1
-        case CCTK_VARIABLE_INT1:
-          *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT1 *) output_numbers[i]) = pow(*( (CCTK_INT1 *) output_numbers[i]), 1.0/4.0); 
-        break;
-        #endif                                                              
-        #ifdef CCTK_INT2
-        case CCTK_VARIABLE_INT2:
-          *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT2 *) output_numbers[i]) = pow(*( (CCTK_INT2 *) output_numbers[i]), 1.0/4.0); 
-        break;
-        #endif
-        #ifdef CCTK_INT4
-        case CCTK_VARIABLE_INT4:
-          *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT4 *) output_numbers[i]) = pow( *( (CCTK_INT4 *) output_numbers[i]), 1.0/4.0); 
-        break;
-        #endif
-        #ifdef CCTK_INT8
-        case CCTK_VARIABLE_INT8:
-          *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
-          *( (CCTK_INT8 *) output_numbers[i]) = pow(*( (CCTK_INT8 *) output_numbers[i]), 1.0/4.0); 
-        break;                                                                
-        #endif
-        case CCTK_VARIABLE_REAL:
-          *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL *) output_numbers[i]) = pow(*( (CCTK_REAL *) output_numbers[i]), 1.0/4.0); 
-        break;
-        #ifdef CCTK_REAL4
-        case CCTK_VARIABLE_REAL4:
-          *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL4 *) output_numbers[i]) = pow(*( (CCTK_REAL4 *) output_numbers[i]), 1.0/4.0); 
-        break;
-        #endif
-        #ifdef CCTK_REAL8
-        case CCTK_VARIABLE_REAL8:
-          *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL8 *) output_numbers[i]) = pow(*( (CCTK_REAL8 *) output_numbers[i]), 1.0/4.0); 
-        break;
-        #endif
-        #ifdef CCTK_REAL16
-        case CCTK_VARIABLE_REAL16:
-          *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
-          *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/4.0); 
-        break;
-        #endif
-        case CCTK_VARIABLE_COMPLEX:
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re;
-          cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re;
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im;
-        break;
-        #ifdef CCTK_COMPLEX8
-        case CCTK_VARIABLE_COMPLEX8:
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re;
-          cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re;
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im;
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX16
-        case CCTK_VARIABLE_COMPLEX16:
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points;
-          cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re;
-          cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re;
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im;
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX32
-        case CCTK_VARIABLE_COMPLEX32:
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
-          cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re;
-          cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im;
-          cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re;
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im;
-        break;
-        #endif
+        switch (output_number_type_codes[i])
+        {
+         /* out values type switches*/
+          case CCTK_VARIABLE_BYTE:
+            *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
+            *( (CCTK_BYTE *) output_numbers[i]) = pow(*( (CCTK_BYTE *) output_numbers[i]), 1.0/4.0); 
+          break;
+          case CCTK_VARIABLE_INT:
+            *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT *) output_numbers[i]) = pow(*( (CCTK_INT *) output_numbers[i]), 1.0/4.0); 
+          break;
+          #ifdef CCTK_INT1
+          case CCTK_VARIABLE_INT1:
+            *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT1 *) output_numbers[i]) = pow(*( (CCTK_INT1 *) output_numbers[i]), 1.0/4.0); 
+          break;
+          #endif                                                              
+          #ifdef CCTK_INT2
+          case CCTK_VARIABLE_INT2:
+            *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT2 *) output_numbers[i]) = pow(*( (CCTK_INT2 *) output_numbers[i]), 1.0/4.0); 
+          break;
+          #endif
+          #ifdef CCTK_INT4
+          case CCTK_VARIABLE_INT4:
+            *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT4 *) output_numbers[i]) = pow( *( (CCTK_INT4 *) output_numbers[i]), 1.0/4.0); 
+          break;
+          #endif
+          #ifdef CCTK_INT8
+          case CCTK_VARIABLE_INT8:
+            *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
+            *( (CCTK_INT8 *) output_numbers[i]) = pow(*( (CCTK_INT8 *) output_numbers[i]), 1.0/4.0); 
+          break;                                                                
+          #endif
+          case CCTK_VARIABLE_REAL:
+            *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL *) output_numbers[i]) = pow(*( (CCTK_REAL *) output_numbers[i]), 1.0/4.0); 
+          break;
+          #ifdef CCTK_REAL4
+          case CCTK_VARIABLE_REAL4:
+            *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL4 *) output_numbers[i]) = pow(*( (CCTK_REAL4 *) output_numbers[i]), 1.0/4.0); 
+          break;
+          #endif
+          #ifdef CCTK_REAL8
+          case CCTK_VARIABLE_REAL8:
+            *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL8 *) output_numbers[i]) = pow(*( (CCTK_REAL8 *) output_numbers[i]), 1.0/4.0); 
+          break;
+          #endif
+          #ifdef CCTK_REAL16
+          case CCTK_VARIABLE_REAL16:
+            *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
+            *( (CCTK_REAL16 *) output_numbers[i]) = pow(*( (CCTK_REAL16 *) output_numbers[i]), 1.0/4.0); 
+          break;
+          #endif
+          case CCTK_VARIABLE_COMPLEX:
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp.Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re;
+            cmplx_tmp.Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Re = cmplx_tmp.Re;
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Im = cmplx_tmp.Im;
+          break;
+          #ifdef CCTK_COMPLEX8
+          case CCTK_VARIABLE_COMPLEX8:
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp8.Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re;
+            cmplx_tmp8.Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = cmplx_tmp8.Re;
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = cmplx_tmp8.Im;
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX16
+          case CCTK_VARIABLE_COMPLEX16:
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points;
+            cmplx_tmp16.Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re;
+            cmplx_tmp16.Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = cmplx_tmp16.Re;
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = cmplx_tmp16.Im;
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX32
+          case CCTK_VARIABLE_COMPLEX32:
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
+            cmplx_tmp32.Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re;
+            cmplx_tmp32.Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im;
+            cmplx_tmp = CCTK_CmplxPow(cmplx_tmp, 1.0/4.0);
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = cmplx_tmp32.Re;
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = cmplx_tmp32.Im;
+          break;
+          #endif
+        }
       }
     }
   }
diff --git a/src/ReductionNormInf.c b/src/ReductionNormInf.c
index 9b7d437..9341b5a 100644
--- a/src/ReductionNormInf.c
+++ b/src/ReductionNormInf.c
@@ -34,55 +34,6 @@ static int ReductionLInf (int N_dims, int operator_handle,
                         const CCTK_INT output_number_type_codes[],
                         void * const output_numbers[]);
 
-/* NormInf reduction functions */
-int LocalReduce_NormInf_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-
-int LocalReduce_NormInf_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-
-#ifdef CCTK_INT1
-int LocalReduce_NormInf_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif                                                              
-
-#ifdef CCTK_INT2
-int LocalReduce_NormInf_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_INT4
-int LocalReduce_NormInf_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_INT8
-int LocalReduce_NormInf_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-int LocalReduce_NormInf_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-
-#ifdef CCTK_REAL4
-int LocalReduce_NormInf_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_REAL8
-int LocalReduce_NormInf_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_REAL16
-int LocalReduce_NormInf_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-int LocalReduce_NormInf_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-
-#ifdef CCTK_COMPLEX8
-int LocalReduce_NormInf_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_COMPLEX16
-int LocalReduce_NormInf_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
-#ifdef CCTK_COMPLEX32
-int LocalReduce_NormInf_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
-#endif
-
 /*@@
   @routine LocalReduce_LInf
   @author  Tom Goodale, Yaakoub Y El Khamra
@@ -201,17 +152,12 @@ static int ReductionLInf (int N_dims, int operator_handle,
   CCTK_INT * input_array_min_subscripts;
   CCTK_INT * input_array_max_subscripts;
 
-  /* excesion variables declared here */
-  int mask_on = 1;          /* mask is by default off=1 */
-  void * mask_array;        /* same dimensions/indexing as input arrays */
-  CCTK_INT mask_type_code;  /* one of the CCTK_VARIABLE_* codes */
-  CCTK_INT mask_offset;
-  CCTK_INT mask_time_level;
+  /* weight variables declared here */
+  int weight_on = 0;          /* weight is by default off=0 */
+  void const * weight;        /* pointer to the weight variable */  
+  CCTK_REAL weight_sum;
 
   /* prevent warnings for unused vars */
-  (void)(mask_array);
-  (void)(mask_offset + 0);
-  (void)(mask_time_level + 0);
   (void)(operator_handle + 0);
 
   /* set the number of points */
@@ -257,20 +203,16 @@ static int ReductionLInf (int N_dims, int operator_handle,
              N_dims, input_array_max_subscripts, "input_array_max_subscripts");  
   }
 
-  /* for masks get values from param table (it they exist) */
+  /* for weights get values from param table (it they exist) */
   if ( Util_TableQueryNKeys(param_table_handle) != 0)
   {
     ierr = 0;
-    ierr = Util_TableGetInt(param_table_handle, &mask_type_code, "mask_type_code"); 
-
-     /*   mask_valid_min, mask_valid_max; 
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_min");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_max");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_array, "mask_array");  */ 
+    /* Get the weight_on parameter and the weight_var_index parameter */
+    ierr = Util_TableGetInt(param_table_handle, &weight_on, "weight_on");
+    ierr = Util_TableGetPointerToConst(param_table_handle, &weight, "weight");
+    /* Need to add more checking here for size, storage */
   }
+
   /* reduction maps an array to a single value of the same type */
   if (M_output_numbers != N_input_arrays)
   {
@@ -314,70 +256,73 @@ static int ReductionLInf (int N_dims, int operator_handle,
     {
     /* in values type switches*/
       case CCTK_VARIABLE_BYTE:
-        num_points = LocalReduce_NormInf_BYTE(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_BYTE(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       case CCTK_VARIABLE_INT:
-        num_points = LocalReduce_NormInf_INT(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_INT(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_INT1
       case CCTK_VARIABLE_INT1:
-        num_points = LocalReduce_NormInf_INT1(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_INT1(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif                                                              
       #ifdef CCTK_INT2
       case CCTK_VARIABLE_INT2:
-        num_points = LocalReduce_NormInf_INT2(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_INT2(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT4
       case CCTK_VARIABLE_INT4:
-        num_points = LocalReduce_NormInf_INT4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_INT4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT8
       case CCTK_VARIABLE_INT8:
-        num_points = LocalReduce_NormInf_INT8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_INT8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;                                                                
       #endif
       case CCTK_VARIABLE_REAL:
-        num_points = LocalReduce_NormInf_REAL(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_REAL(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_REAL4
       case CCTK_VARIABLE_REAL4:
-        num_points = LocalReduce_NormInf_REAL4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_REAL4(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL8
       case CCTK_VARIABLE_REAL8:
-        num_points = LocalReduce_NormInf_REAL8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_REAL8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL16
       case CCTK_VARIABLE_REAL16:
-        num_points = LocalReduce_NormInf_REAL16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_REAL16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif  
       case CCTK_VARIABLE_COMPLEX:
-        num_points = LocalReduce_NormInf_COMPLEX(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_COMPLEX(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_COMPLEX8
       case CCTK_VARIABLE_COMPLEX8:
-        num_points = LocalReduce_NormInf_COMPLEX8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_COMPLEX8(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX16
       case CCTK_VARIABLE_COMPLEX16:
-        num_points = LocalReduce_NormInf_COMPLEX16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_COMPLEX16(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX32
       case CCTK_VARIABLE_COMPLEX32:
-        num_points = LocalReduce_NormInf_COMPLEX32(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        ierr = LocalReduce_NormInf_COMPLEX32(i, weight_on, weight, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
     }
   }
 
+  /* Get the values of num_points and weight_sum */
+  ierr = Util_TableGetInt(param_table_handle, &num_points, "num_points");
+  ierr = Util_TableGetReal(param_table_handle, &weight_sum, "weight_sum");
   num_points--;
 
   /* store the number of points in the paramater table  and perform division */
@@ -390,77 +335,164 @@ static int ReductionLInf (int N_dims, int operator_handle,
   }
   else
   {
-    for (i = 0; i< M_output_numbers; i++)
+    if (weight_on == 1)
+    {
+      if (ABS(weight_sum) > 1e-12)
+      {
+        for (i = 0; i< M_output_numbers; i++)
+        {
+          switch (output_number_type_codes[i])
+          {
+            /* out values type switches*/
+            case CCTK_VARIABLE_BYTE:
+              *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / weight_sum; 
+            break;
+            case CCTK_VARIABLE_INT:
+              *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / weight_sum; 
+            break;
+            #ifdef CCTK_INT1
+            case CCTK_VARIABLE_INT1:
+              *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif                                                              
+            #ifdef CCTK_INT2
+            case CCTK_VARIABLE_INT2:
+              *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_INT4
+            case CCTK_VARIABLE_INT4:
+              *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_INT8
+            case CCTK_VARIABLE_INT8:
+              *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / weight_sum; 
+            break;                                                                
+            #endif
+            case CCTK_VARIABLE_REAL:
+              *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / weight_sum; 
+            break;
+            #ifdef CCTK_REAL4
+            case CCTK_VARIABLE_REAL4:
+              *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_REAL8
+            case CCTK_VARIABLE_REAL8:
+              *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_REAL16
+            case CCTK_VARIABLE_REAL16:
+              *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / weight_sum; 
+            break;
+            #endif
+            case CCTK_VARIABLE_COMPLEX:
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #ifdef CCTK_COMPLEX8
+            case CCTK_VARIABLE_COMPLEX8:
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX16
+            case CCTK_VARIABLE_COMPLEX16:
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #endif
+            #ifdef CCTK_COMPLEX32
+            case CCTK_VARIABLE_COMPLEX32:
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / weight_sum; 
+              (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / weight_sum; 
+            break;
+            #endif
+          }
+        }
+      }
+      else
+      {
+        CCTK_WARN (1, "The sum of weights in average reduction is zero");
+        return (-1);
+      }
+    }
+    else
     {
-      switch (output_number_type_codes[i])
+      for (i = 0; i< M_output_numbers; i++)
       {
-       /* out values type switches*/
-        case CCTK_VARIABLE_BYTE:
-          *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
-        break;
-        case CCTK_VARIABLE_INT:
-          *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
-        break;
-        #ifdef CCTK_INT1
-        case CCTK_VARIABLE_INT1:
-          *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
-        break;
-        #endif                                                              
-        #ifdef CCTK_INT2
-        case CCTK_VARIABLE_INT2:
-          *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_INT4
-        case CCTK_VARIABLE_INT4:
-          *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_INT8
-        case CCTK_VARIABLE_INT8:
-          *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
-        break;                                                                
-        #endif
-        case CCTK_VARIABLE_REAL:
-          *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
-        break;
-        #ifdef CCTK_REAL4
-        case CCTK_VARIABLE_REAL4:
-          *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_REAL8
-        case CCTK_VARIABLE_REAL8:
-          *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_REAL16
-        case CCTK_VARIABLE_REAL16:
-          *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
-        break;
-        #endif
-        case CCTK_VARIABLE_COMPLEX:
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
-        break;
-        #ifdef CCTK_COMPLEX8
-        case CCTK_VARIABLE_COMPLEX8:
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX16
-        case CCTK_VARIABLE_COMPLEX16:
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; 
-        break;
-        #endif
-        #ifdef CCTK_COMPLEX32
-        case CCTK_VARIABLE_COMPLEX32:
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
-          (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
-        break;
-        #endif
+        switch (output_number_type_codes[i])
+        {
+         /* out values type switches*/
+          case CCTK_VARIABLE_BYTE:
+            *( (CCTK_BYTE *) output_numbers[i]) = *( (CCTK_BYTE *) output_numbers[i]) / num_points; 
+          break;
+          case CCTK_VARIABLE_INT:
+            *( (CCTK_INT *) output_numbers[i]) = *( (CCTK_INT *) output_numbers[i]) / num_points; 
+          break;
+          #ifdef CCTK_INT1
+          case CCTK_VARIABLE_INT1:
+            *( (CCTK_INT1 *) output_numbers[i]) = *( (CCTK_INT1 *) output_numbers[i]) / num_points; 
+          break;
+          #endif                                                              
+          #ifdef CCTK_INT2
+          case CCTK_VARIABLE_INT2:
+            *( (CCTK_INT2 *) output_numbers[i]) = *( (CCTK_INT2 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_INT4
+          case CCTK_VARIABLE_INT4:
+            *( (CCTK_INT4 *) output_numbers[i]) = *( (CCTK_INT4 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_INT8
+          case CCTK_VARIABLE_INT8:
+            *( (CCTK_INT8 *) output_numbers[i]) = *( (CCTK_INT8 *) output_numbers[i]) / num_points; 
+          break;                                                                
+          #endif
+          case CCTK_VARIABLE_REAL:
+            *( (CCTK_REAL *) output_numbers[i]) = *( (CCTK_REAL *) output_numbers[i]) / num_points; 
+          break;
+          #ifdef CCTK_REAL4
+          case CCTK_VARIABLE_REAL4:
+            *( (CCTK_REAL4 *) output_numbers[i]) = *( (CCTK_REAL4 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_REAL8
+          case CCTK_VARIABLE_REAL8:
+            *( (CCTK_REAL8 *) output_numbers[i]) = *( (CCTK_REAL8 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_REAL16
+          case CCTK_VARIABLE_REAL16:
+            *( (CCTK_REAL16 *) output_numbers[i]) = *( (CCTK_REAL16 *) output_numbers[i]) / num_points; 
+          break;
+          #endif
+          case CCTK_VARIABLE_COMPLEX:
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Re = (*( (CCTK_COMPLEX *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX *) output_numbers[i])).Im = (*( (CCTK_COMPLEX *) output_numbers[i])).Im / num_points; 
+          break;
+          #ifdef CCTK_COMPLEX8
+          case CCTK_VARIABLE_COMPLEX8:
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX8 *) output_numbers[i])).Im / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX16
+          case CCTK_VARIABLE_COMPLEX16:
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX16 *) output_numbers[i])).Im / num_points; 
+          break;
+          #endif
+          #ifdef CCTK_COMPLEX32
+          case CCTK_VARIABLE_COMPLEX32:
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Re / num_points; 
+            (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im = (*( (CCTK_COMPLEX32 *) output_numbers[i])).Im / num_points; 
+          break;
+          #endif
+        }
       }
     }
   }
diff --git a/src/ReductionSum.c b/src/ReductionSum.c
index 480e855..d132611 100644
--- a/src/ReductionSum.c
+++ b/src/ReductionSum.c
@@ -139,6 +139,7 @@ static int ReductionSum (int N_dims, int operator_handle,
   int i, j, num_points;
   int ierr;
   int * iters_per_dim;
+  int global_calling = 0;
 
   /* indices to hold the temp indices of size N_dims  and iteration indices*/
   int * indices;
@@ -153,17 +154,12 @@ static int ReductionSum (int N_dims, int operator_handle,
   CCTK_INT * input_array_min_subscripts;
   CCTK_INT * input_array_max_subscripts;
 
-  /* excesion variables declared here */
-  int mask_on = 1;          /* mask is by default off=1 */
-  void * mask_array;        /* same dimensions/indexing as input arrays */
-  CCTK_INT mask_type_code;  /* one of the CCTK_VARIABLE_* codes */
-  CCTK_INT mask_offset;
-  CCTK_INT mask_time_level;
+  /* weight variables declared here */
+  int weight_on = 0;          /* weight is by default off=0 */
+  void const * weight;        /* pointer to the weight variable */  
+  CCTK_REAL weight_sum;
 
   /* prevent warnings for unused vars */
-  (void)(mask_array);
-  (void)(mask_offset + 0);
-  (void)(mask_time_level + 0);
   (void)(operator_handle + 0);
 
   /* set the number of points */
@@ -209,20 +205,16 @@ static int ReductionSum (int N_dims, int operator_handle,
              N_dims, input_array_max_subscripts, "input_array_max_subscripts");  
   }
 
-  /* for masks get values from param table (it they exist) */
+  /* for weights get values from param table (it they exist) */
   if ( Util_TableQueryNKeys(param_table_handle) != 0)
   {
     ierr = 0;
-    ierr = Util_TableGetInt(param_table_handle, &mask_type_code, "mask_type_code"); 
-
-     /*   mask_valid_min, mask_valid_max; 
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_min");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_range, "mask_valid_max");
-    ierr = Util_TableGetGeneric(param_table_handle, mask_type_code, 
-              mask_array, "mask_array");  */ 
+    /* Get the weight_on parameter and the weight_var_index parameter */
+    ierr = Util_TableGetInt(param_table_handle, &weight_on, "weight_on");
+    ierr = Util_TableGetPointerToConst(param_table_handle, &weight, "weight");
+    /* Need to add more checking here for size, storage */
   }
+
   /* reduction maps an array to a single value of the same type */
   if (M_output_numbers != N_input_arrays)
   {
@@ -257,74 +249,78 @@ static int ReductionSum (int N_dims, int operator_handle,
     {
     /* in values type switches*/
       case CCTK_VARIABLE_BYTE:
-        num_points = LocalReduce_Sum_BYTE(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_BYTE(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       case CCTK_VARIABLE_INT:
-        num_points = LocalReduce_Sum_INT(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_INT(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_INT1
       case CCTK_VARIABLE_INT1:
-        num_points = LocalReduce_Sum_INT1(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_INT1(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif                                                              
       #ifdef CCTK_INT2
       case CCTK_VARIABLE_INT2:
-        num_points = LocalReduce_Sum_INT2(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_INT2(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT4
       case CCTK_VARIABLE_INT4:
-        num_points = LocalReduce_Sum_INT4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_INT4(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_INT8
       case CCTK_VARIABLE_INT8:
-        num_points = LocalReduce_Sum_INT8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_INT8(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;                                                                
       #endif
       case CCTK_VARIABLE_REAL:
-        num_points = LocalReduce_Sum_REAL(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_REAL(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_REAL4
       case CCTK_VARIABLE_REAL4:
-        num_points = LocalReduce_Sum_REAL4(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_REAL4(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL8
       case CCTK_VARIABLE_REAL8:
-        num_points = LocalReduce_Sum_REAL8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_REAL8(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_REAL16
       case CCTK_VARIABLE_REAL16:
-        num_points = LocalReduce_Sum_REAL16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_REAL16(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif  
       case CCTK_VARIABLE_COMPLEX:
-        num_points = LocalReduce_Sum_COMPLEX(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_COMPLEX(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #ifdef CCTK_COMPLEX8
       case CCTK_VARIABLE_COMPLEX8:
-        num_points = LocalReduce_Sum_COMPLEX8(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_COMPLEX8(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX16
       case CCTK_VARIABLE_COMPLEX16:
-        num_points = LocalReduce_Sum_COMPLEX16(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_COMPLEX16(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
       #ifdef CCTK_COMPLEX32
       case CCTK_VARIABLE_COMPLEX32:
-        num_points = LocalReduce_Sum_COMPLEX32(i, mask_on, input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers);
+        num_points = LocalReduce_Sum_COMPLEX32(i, weight_on, weight,  input_array_offsets, indices, max_iter, actual_indices, input_array_strides, input_array_min_subscripts, input_array_dims, num_points, actual_iters_per_dim, iters_per_dim,   N_dims, input_arrays, output_number_type_codes, output_numbers, param_table_handle);
       break;
       #endif
     }
   }
 
+  /* Get the values of num_points and weight_sum */
+  ierr = Util_TableGetInt(param_table_handle, &num_points, "num_points");
+  ierr = Util_TableGetReal(param_table_handle, &weight_sum, "weight_sum");
   num_points--;
 
-  /* store the number of points in the paramater table */
-  if ( Util_TableQueryNKeys(param_table_handle) != 0)
+  /* store the number of points in the paramater table  and perform division */
+  ierr = Util_TableGetInt(param_table_handle, &global_calling, "global_calling");
+  if ( global_calling != 0)
   {
     ierr = Util_TableSetInt(param_table_handle, num_points, "num_points");
     ierr = Util_TableSetInt(param_table_handle, 3,"global_operation");
@@ -343,5 +339,3 @@ static int ReductionSum (int N_dims, int operator_handle,
                                                                                 
   return (0);
 }
-
-
diff --git a/src/SumFunctions.c b/src/SumFunctions.c
index 401c5a0..dca7920 100644
--- a/src/SumFunctions.c
+++ b/src/SumFunctions.c
@@ -18,13 +18,18 @@ extern "C" {
 #endif
 
 
-int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -32,6 +37,7 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -39,51 +45,52 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -103,10 +110,12 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -114,6 +123,7 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -121,6 +131,7 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -139,10 +150,12 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -150,6 +163,7 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -158,6 +172,7 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -176,11 +191,13 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -188,6 +205,7 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -196,6 +214,7 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -214,11 +233,13 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_BYTE, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -226,6 +247,7 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -234,13 +256,18 @@ int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int
   return num_points;
 }
 
-int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -248,6 +275,7 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -255,51 +283,52 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -318,10 +347,12 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -329,6 +360,7 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -336,6 +368,7 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -354,10 +387,12 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -365,6 +400,7 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -373,6 +409,7 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -391,10 +428,12 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -402,6 +441,7 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -410,6 +450,7 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -428,10 +469,12 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -439,6 +482,7 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -448,13 +492,18 @@ int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int
 }
 
 #ifdef CCTK_INT1
-int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -462,6 +511,7 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -469,51 +519,52 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT11
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT12
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT14
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT18
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -532,10 +583,12 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -543,6 +596,7 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -550,6 +604,7 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -568,10 +623,12 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -579,6 +636,7 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -587,6 +645,7 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -605,11 +664,13 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -617,6 +678,7 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -625,6 +687,7 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -643,11 +706,13 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT1, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -655,6 +720,7 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -665,13 +731,18 @@ int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -679,6 +750,7 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -686,51 +758,52 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT21
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT22
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT24
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT28
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -749,10 +822,12 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -760,6 +835,7 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -767,6 +843,7 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -785,10 +862,12 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -796,6 +875,7 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -804,6 +884,7 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -822,11 +903,13 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -834,6 +917,7 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -842,6 +926,7 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -860,11 +945,13 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT2, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -872,6 +959,7 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -882,13 +970,18 @@ int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -896,6 +989,7 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -903,51 +997,52 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -966,10 +1061,12 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -977,6 +1074,7 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -984,6 +1082,7 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1002,10 +1101,12 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1013,6 +1114,7 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1021,6 +1123,7 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1039,11 +1142,13 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1051,6 +1156,7 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1059,6 +1165,7 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1077,11 +1184,13 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1089,6 +1198,7 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -1099,13 +1209,18 @@ int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1113,6 +1228,7 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1120,51 +1236,52 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1183,10 +1300,12 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1194,6 +1313,7 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1201,6 +1321,7 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1219,10 +1340,12 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1230,6 +1353,7 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1238,6 +1362,7 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1256,11 +1381,13 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1268,6 +1395,7 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1276,6 +1404,7 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1294,11 +1423,13 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_INT8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1306,6 +1437,7 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -1315,13 +1447,18 @@ int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int
 }
 #endif
 
-int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1329,6 +1466,7 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1336,51 +1474,52 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1399,10 +1538,12 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1410,6 +1551,7 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1417,6 +1559,7 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1435,10 +1578,12 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1446,6 +1591,7 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1454,6 +1600,7 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1472,11 +1619,13 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1484,6 +1633,7 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1492,6 +1642,7 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1510,11 +1661,13 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1522,6 +1675,7 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -1531,13 +1685,18 @@ int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int
 }
 
 #ifdef CCTK_REAL4
-int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1545,6 +1704,7 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1552,51 +1712,52 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1615,10 +1776,12 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1626,6 +1789,7 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1633,6 +1797,7 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1651,10 +1816,12 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1662,6 +1829,7 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1670,6 +1838,7 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1688,11 +1857,13 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1700,6 +1871,7 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1708,6 +1880,7 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1726,11 +1899,13 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL4, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1738,6 +1913,7 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -1748,13 +1924,18 @@ int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1762,6 +1943,7 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1769,51 +1951,52 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1832,10 +2015,12 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1843,6 +2028,7 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1850,6 +2036,7 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1868,10 +2055,12 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1879,6 +2068,7 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1887,6 +2077,7 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1905,11 +2096,13 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1917,6 +2110,7 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1925,6 +2119,7 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1943,11 +2138,13 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1956,6 +2153,7 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
         inval = (out_type) typed_vdata[sum_indices];
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -1966,13 +2164,18 @@ int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, in
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -1980,6 +2183,7 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -1987,51 +2191,52 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2050,10 +2255,12 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2061,6 +2268,7 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2068,6 +2276,7 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2086,10 +2295,12 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2097,6 +2308,7 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2105,6 +2317,7 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2123,11 +2336,13 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2135,6 +2350,7 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2143,6 +2359,7 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2161,11 +2378,13 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
         inval.Re = (CCTK_REAL16) typed_vdata[sum_indices];
 #endif
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_REAL16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 #undef REDUCTION_PREOP_CAST
@@ -2173,6 +2392,7 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 #define REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type) \
         inval = (out_type) typed_vdata[sum_indices];
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -2182,13 +2402,18 @@ int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, i
 }
 #endif
 
-int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2207,6 +2432,7 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2214,51 +2440,52 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2267,10 +2494,12 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2289,6 +2518,7 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2296,6 +2526,7 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2304,10 +2535,12 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2326,6 +2559,7 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2334,6 +2568,7 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2342,11 +2577,13 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2365,6 +2602,7 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2373,6 +2611,7 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2381,11 +2620,13 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2404,6 +2645,7 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -2414,13 +2656,18 @@ int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets,
 
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2439,6 +2686,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2446,51 +2694,52 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2499,10 +2748,12 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2521,6 +2772,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2528,6 +2780,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2536,10 +2789,12 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2558,6 +2813,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2566,6 +2822,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2574,11 +2831,13 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2597,6 +2856,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2605,6 +2865,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2613,11 +2874,13 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX8, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2636,6 +2899,7 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -2646,13 +2910,18 @@ int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets,
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2671,6 +2940,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2678,51 +2948,52 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_BYTE, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2731,10 +3002,12 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2753,6 +3026,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2760,6 +3034,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2768,10 +3043,12 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2790,6 +3067,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2798,6 +3076,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2806,11 +3085,13 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2829,6 +3110,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2837,6 +3119,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2845,11 +3128,13 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX16, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2868,6 +3153,7 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
@@ -2878,13 +3164,18 @@ int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[])
+int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle)
 {
   int iter = 0;
   int sum_indices = 0;
-  int flag, product, j, k;
+  int flag, product, j, k, ierr;
+
+  /* Weight variables */
+  CCTK_REAL weight_sum = 0.0;
+  CCTK_REAL weight_value = 1.0;
 
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2903,6 +3194,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2910,51 +3202,52 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
   {
     /* out values type switches*/
     case CCTK_VARIABLE_BYTE:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     case CCTK_VARIABLE_INT:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_INT1
     case CCTK_VARIABLE_INT1:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT1, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif                                                              
     #ifdef CCTK_INT2
     case CCTK_VARIABLE_INT2:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT2, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT4
     case CCTK_VARIABLE_INT4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_INT8
     case CCTK_VARIABLE_INT8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_INT8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;                                                                
     #endif
     case CCTK_VARIABLE_REAL:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #ifdef CCTK_REAL4
     case CCTK_VARIABLE_REAL4:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL4, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL8
     case CCTK_VARIABLE_REAL8:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     #ifdef CCTK_REAL16
     case CCTK_VARIABLE_REAL16:
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_REAL16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
     break;
     #endif
     case CCTK_VARIABLE_COMPLEX:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2963,10 +3256,12 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -2985,6 +3280,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -2992,6 +3288,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX8
     case CCTK_VARIABLE_COMPLEX8:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3000,10 +3297,12 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL4) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL4) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd8( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd8( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX8, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3022,6 +3321,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3030,6 +3330,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX16
     case CCTK_VARIABLE_COMPLEX16:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3038,11 +3339,13 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL8) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL8) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd16( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd16( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX16, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3061,6 +3364,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
 
@@ -3069,6 +3373,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
     #ifdef CCTK_COMPLEX32
     case CCTK_VARIABLE_COMPLEX32:
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3077,11 +3382,13 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
         (inval).Re = (CCTK_REAL16) (typed_vdata[sum_indices]).Re; (inval).Im = (CCTK_REAL16) (typed_vdata[sum_indices]).Im;
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = CCTK_CmplxAdd32( Sum, scalar);
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   scalar.Re=scalar.Re*weight; scalar.Im=scalar.Im*weight; Sum = CCTK_CmplxAdd32( Sum, scalar);
 #define REDUCTION_INITIAL(num) (num).Re = 0.0; (num).Im = 0.0;
 #define EXTRA_STEP(a, b)
 
-      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], mask_on, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
+      ITERATE_ON_ARRAY(i,CCTK_COMPLEX32, input_arrays[i], CCTK_COMPLEX32, output_numbers[i], weight_on, weight, input_array_offsets[i], indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)
 #undef REDUCTION_OPERATION
+#undef WEIGHTED_REDUCTION_OPERATION
 #undef REDUCTION_INITIAL
 #undef EXTRA_STEP
 
@@ -3100,6 +3407,7 @@ int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets
 #endif
 
 #define REDUCTION_OPERATION(Sum, scalar)   Sum = Sum + scalar;
+#define WEIGHTED_REDUCTION_OPERATION(Sum, scalar, weight)   Sum = Sum + scalar*weight;
 #define REDUCTION_INITIAL(num) num = 0;
 #define EXTRA_STEP(a, b)
     break;
diff --git a/src/Sum_Functions.h b/src/Sum_Functions.h
index 2a483bd..7dde9de 100644
--- a/src/Sum_Functions.h
+++ b/src/Sum_Functions.h
@@ -18,52 +18,52 @@ extern "C" {
 #endif
 
 /* Sum reduction functions */
-int LocalReduce_Sum_BYTE(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_BYTE(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
-int LocalReduce_Sum_INT(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_INT(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_INT1
-int LocalReduce_Sum_INT1(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_INT1(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif                                                              
 
 #ifdef CCTK_INT2
-int LocalReduce_Sum_INT2(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_INT2(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT4
-int LocalReduce_Sum_INT4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_INT4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_INT8
-int LocalReduce_Sum_INT8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_INT8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Sum_REAL(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_REAL(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_REAL4
-int LocalReduce_Sum_REAL4(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_REAL4(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL8
-int LocalReduce_Sum_REAL8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_REAL8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_REAL16
-int LocalReduce_Sum_REAL16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_REAL16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
-int LocalReduce_Sum_COMPLEX(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_COMPLEX(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 
 #ifdef CCTK_COMPLEX8
-int LocalReduce_Sum_COMPLEX8(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_COMPLEX8(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX16
-int LocalReduce_Sum_COMPLEX16(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_COMPLEX16(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef CCTK_COMPLEX32
-int LocalReduce_Sum_COMPLEX32(int i, int mask_on, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[]);
+int LocalReduce_Sum_COMPLEX32(int i, int weight_on, const void * const weight, CCTK_INT * input_array_offsets, int * indices, int max_iter, int * actual_indices, CCTK_INT * input_array_strides, CCTK_INT * input_array_min_subscripts,const CCTK_INT * input_array_dims, int num_points, int * actual_iters_per_dim, int * iters_per_dim,    int N_dims, const void *const input_arrays[], const CCTK_INT output_number_type_codes[], void * const output_numbers[], int param_table_handle);
 #endif
 
 #ifdef __cplusplus
diff --git a/src/local_reductions.h b/src/local_reductions.h
index f7451f1..6316063 100644
--- a/src/local_reductions.h
+++ b/src/local_reductions.h
@@ -16,14 +16,14 @@
 #include "util_Table.h"
 #include "cctk_Reduction.h"
 
-
+#define ABS(x)      ((x) < 0 ? -(x) : (x))
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 
-#define ITERATE_ON_ARRAY(i,cctk_type, in_data, out_type, out_num, mask_on,input_array_offset, indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)           \
+#define ITERATE_ON_ARRAY(i,cctk_type, in_data, out_type, out_num, weight_on, weight, input_array_offset, indices, sum_indices, max_iter, iter, flag, actual_indices,input_array_strides, input_array_min_subscripts,input_array_dims,product)           \
 {                                                                                 \
   const cctk_type * typed_vdata = (const cctk_type *)(in_data);                   \
   out_type inval;                                                                 \
@@ -40,7 +40,117 @@ extern "C" {
   }                                                                               \
   else                                                                            \
   {                                                                               \
-  if ( mask_on == 1)                                                              \
+  if ( weight_on == 1)                                                            \
+  {                                                                               \
+    if ( input_array_offset == 0)                                                 \
+    {                                                                             \
+      while (iter < max_iter)                                                     \
+      {                                                                           \
+        sum_indices = actual_indices[0];                                          \
+        for (k=N_dims-1;k>0;k--)                                                  \
+        {                                                                         \
+          product = 1;                                                            \
+          for (j=k-1;j>=0;j--)                                                    \
+          {                                                                       \
+            product *= input_array_dims[j];                                       \
+          }                                                                       \
+          sum_indices += actual_indices[k]*product;                               \
+        }                                                                         \
+        weight_value = ((CCTK_REAL *) weight)[sum_indices];                       \
+                                                                                  \
+        REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type);           \
+        WEIGHTED_REDUCTION_OPERATION(*outval,inval,weight_value);                 \
+        num_points++;                                                             \
+        weight_sum += weight_value;                                               \
+        iter++;                                                                   \
+        flag = 0;                                                                 \
+        for (k=0;k<N_dims;k++)                                                    \
+        {                                                                         \
+          if( indices[k] < iters_per_dim[k]-1)                                    \
+          {                                                                       \
+            if (flag==1)                                                          \
+            {                                                                     \
+              actual_indices[k] += input_array_strides[k];                        \
+              indices[k]++;                                                       \
+              flag = 0;                                                           \
+              break;                                                              \
+            }                                                                     \
+            indices[k]++;                                                         \
+            actual_indices[k] += input_array_strides[k];                          \
+            break;                                                                \
+          }                                                                       \
+          else if (indices[k] == iters_per_dim[k]-1)                              \
+          {                                                                       \
+            indices[k] = 0;                                                       \
+            actual_indices[k] = input_array_min_subscripts[k];                    \
+            flag = 1;                                                             \
+            continue;                                                             \
+          }                                                                       \
+          else                                                                    \
+          {                                                                       \
+            CCTK_WARN(1,"indices out of bounds, this should not happen");         \
+            return -1;                                                            \
+          }                                                                       \
+        }                                                                         \
+      }                                                                           \
+    }                                                                             \
+    else                                                                          \
+    {                                                                             \
+      while (iter < max_iter)                                                     \
+      {                                                                           \
+        sum_indices = actual_indices[0];                                          \
+        for (k=N_dims-1;k>0;k--)                                                  \
+        {                                                                         \
+          product = 1;                                                            \
+          for (j=k-1;j>=0;j--)                                                    \
+          {                                                                       \
+            product *= actual_iters_per_dim[j];                                   \
+          }                                                                       \
+          sum_indices += actual_indices[k]*product;                               \
+        }                                                                         \
+        /* prevent offset from giving segfaults */                                \
+        if (sum_indices >= max_iter)                                              \
+        {                                                                         \
+          CCTK_WARN(1,"offsets and strides access unallocated memory");           \
+          return -1;                                                              \
+        }                                                                         \
+        REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type);           \
+        WEIGHTED_REDUCTION_OPERATION(*outval,inval,weight_value);                 \
+        num_points++;                                                             \
+        iter++;                                                                   \
+        flag = 0;                                                                 \
+        for (k=0;k<N_dims;k++)                                                    \
+        {                                                                         \
+          if( indices[k] < iters_per_dim[k]-1)                                    \
+          {                                                                       \
+            if (flag==1)                                                          \
+            {                                                                     \
+              actual_indices[k] += input_array_strides[k-1];                      \
+              indices[k]++;                                                       \
+              flag = 0;                                                           \
+              break;                                                              \
+            }                                                                     \
+            indices[k]++;                                                         \
+            actual_indices[k] += input_array_strides[k];                          \
+            break;                                                                \
+          }                                                                       \
+          else if (indices[k] == iters_per_dim[k]-1)                              \
+          {                                                                       \
+            indices[k] = 0;                                                       \
+            actual_indices[k] = input_array_min_subscripts[k];                    \
+            flag = 1;                                                             \
+            continue;                                                             \
+          }                                                                       \
+          else                                                                    \
+          {                                                                       \
+            CCTK_WARN(1,"indices out of bounds, this should not happen");         \
+            return -1;                                                            \
+          }                                                                       \
+        }                                                                         \
+      }                                                                           \
+    }                                                                             \
+  }                                                                               \
+  else if (weight_on ==0)                                                         \
   {                                                                               \
     if ( input_array_offset == 0)                                                 \
     {                                                                             \
@@ -59,6 +169,7 @@ extern "C" {
         REDUCTION_PREOP_CAST(inval, typed_vdata,sum_indices, out_type);           \
         REDUCTION_OPERATION(*outval,inval);                                       \
         num_points++;                                                             \
+        weight_sum += weight_value;                                               \
         iter++;                                                                   \
         flag = 0;                                                                 \
         for (k=0;k<N_dims;k++)                                                    \
@@ -149,7 +260,7 @@ extern "C" {
   }                                                                               \
   else                                                                            \
   {                                                                               \
-    CCTK_WARN(1, "mask_on is not set to a valid value");                          \
+    CCTK_WARN(1, "weight_on is not set to a valid value");                        \
   }                                                                               \
   }                                                                               \
   EXTRA_STEP(*outval, (out_type)num_points)                                       \
diff --git a/src/make.code.defn b/src/make.code.defn
index 2e3d01c..30d17ec 100644
--- a/src/make.code.defn
+++ b/src/make.code.defn
@@ -2,7 +2,10 @@
 # $Header$
 
 # Source files in this directory
+
 SRCS = Startup.c Reduction.c ReductionAvg.c  AvgFunctions.c ReductionMax.c MaxFunctions.c  ReductionMin.c MinFunctions.c  ReductionCount.c CountFunctions.c ReductionSum.c SumFunctions.c ReductionNorm1.c Norm1Functions.c ReductionNorm2.c Norm2Functions.c ReductionNorm3.c Norm3Functions.c ReductionNorm4.c Norm4Functions.c ReductionNormInf.c NormInfFunctions.c
 
+#SRCS = Startup.c Reduction.c ReductionAvg.c  AvgFunctions.c 
+
 # Subdirectories containing source files
 SUBDIRS =