From 141990f45d54bffe80e9511c7bae19b65b9bd635 Mon Sep 17 00:00:00 2001 From: yye00 Date: Wed, 14 Sep 2005 22:35:04 +0000 Subject: 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 --- src/AvgFunctions.c | 813 ++++++++++++++++++++++++----------- src/Avg_Functions.h | 28 +- src/CountFunctions.c | 756 +++++++++++++++++++++++---------- src/Count_Functions.h | 28 +- src/MaxFunctions.c | 1078 +++++++++++++++++++++++++++++++---------------- src/Max_Functions.h | 28 +- src/MinFunctions.c | 900 ++++++++++++++++++++++++++------------- src/Min_Functions.h | 28 +- src/Norm1Functions.c | 826 +++++++++++++++++++++++++----------- src/Norm1_Functions.h | 28 +- src/Norm2Functions.c | 822 +++++++++++++++++++++++++----------- src/Norm2_Functions.h | 28 +- src/Norm3Functions.c | 892 +++++++++++++++++++++++++++------------ src/Norm3_Functions.h | 28 +- src/Norm4Functions.c | 852 +++++++++++++++++++++++++------------ src/Norm4_Functions.h | 28 +- src/NormInfFunctions.c | 822 ++++++++++++++++++++++++------------ src/NormInf_Functions.h | 28 +- src/ReductionAvg.c | 331 ++++++++------- src/ReductionCount.c | 76 ++-- src/ReductionMax.c | 66 ++- src/ReductionMin.c | 67 ++- src/ReductionNorm1.c | 281 +++++++----- src/ReductionNorm2.c | 375 +++++++++++------ src/ReductionNorm3.c | 375 +++++++++++------ src/ReductionNorm4.c | 375 +++++++++++------ src/ReductionNormInf.c | 334 ++++++++------- src/ReductionSum.c | 68 ++- src/SumFunctions.c | 756 +++++++++++++++++++++++---------- src/Sum_Functions.h | 28 +- src/local_reductions.h | 119 +++++- src/make.code.defn | 3 + 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;k0;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