Take time levels into account.

git-svn-id: http://svn.cactuscode.org/arrangements/CactusNumerical/RotatingSymmetry90/trunk@13 c3c03602-0f4f-0410-b3fa-d2c81c8a7dc5

1 files changed, 56 insertions, 24 deletions

diff --git a/src/interpolate.c b/src/interpolate.c
index 2d6c369..f0e032b 100644
--- a/src/interpolate.c
+++ b/src/interpolate.c
@@ -268,12 +268,13 @@ Rot90_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
   CCTK_POINTER new_interp_coords[3];
   CCTK_POINTER * restrict new_output_arrays;
   CCTK_INT new_faces;
+  CCTK_INT * restrict input_array_time_levels;
   CCTK_INT * restrict operand_indices;
   CCTK_INT * restrict operation_codes;
   CCTK_INT * restrict output_array_indices;
   
-  struct tensor const * restrict * restrict thetensor[3];
-  int * restrict * restrict thevars[3];
+  struct tensor const * restrict * restrict thetensor[3][4];
+  int * restrict * restrict thevars[3][4];
   int * restrict thebase;
   int * restrict thevar;
   
@@ -283,6 +284,7 @@ Rot90_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
   int f;                        /* face */
   int d;                        /* dimension */
   int q;                        /* number of derivatives */
+  int tl;                       /* time level */
   int r;                        /* rank */
   
   int iret;                     /* interpolator return value */
@@ -373,6 +375,20 @@ Rot90_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
   
   
   /* Find output variable indices */
+  input_array_time_levels
+    = malloc (N_input_arrays * sizeof *input_array_time_levels);
+  assert (input_array_time_levels);
+  ierr = Util_TableGetIntArray
+    (param_table_handle, N_input_arrays,
+     input_array_time_levels, "input_array_time_levels");
+  if (ierr == UTIL_ERROR_TABLE_NO_SUCH_KEY) {
+    for (m=0; m<N_input_arrays; ++m) {
+      input_array_time_levels[m] = 0; /* time level is 0 */
+    }
+  } else {
+    assert (ierr == N_input_arrays);
+  }
+  
   operand_indices = malloc (N_output_arrays * sizeof *operand_indices);
   assert (operand_indices);
   ierr = Util_TableGetIntArray
@@ -413,13 +429,15 @@ Rot90_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
   
   /* Map Cactus variables to tensor objects */
   for (q=0; q<3; ++q) {
-    thetensor[q] = malloc (CCTK_NumVars() * sizeof *thetensor[q]);
-    assert (thetensor[q]);
-    thevars[q] = malloc (CCTK_NumVars() * sizeof *thevars[q]);
-    assert (thevars[q]);
-    for (n=0; n<CCTK_NumVars(); ++n) {
-      thetensor[q][n] = NULL;
-      thevars[q][n] = NULL;
+    for (tl=0; tl<4; ++tl) {
+      thetensor[q][tl] = malloc (CCTK_NumVars() * sizeof *thetensor[q][tl]);
+      assert (thetensor[q][tl]);
+      thevars[q][tl] = malloc (CCTK_NumVars() * sizeof *thevars[q][tl]);
+      assert (thevars[q][tl]);
+      for (n=0; n<CCTK_NumVars(); ++n) {
+        thetensor[q][tl][n] = NULL;
+        thevars[q][tl][n] = NULL;
+      }
     }
   }
   
@@ -444,6 +462,7 @@ Rot90_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
     int indices[10];
     int oldrank;
     int num_derivs;
+    int time_level;
     
     /* Get some variable information */
     vi = output_array_indices[m];
@@ -542,6 +561,10 @@ Rot90_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
       assert (num_derivs>=0);
     }
     
+    /* Get the time level */
+    time_level = input_array_time_levels[operand_indices[m]];
+    assert (time_level>=0 && time_level<4);
+    
     if (tensortype == &scalar) {
       switch (num_derivs) {
       case 0: break;
@@ -594,20 +617,21 @@ Rot90_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
     }
     
     /* Create or cross-check the tensor object */
-    if (! thetensor[num_derivs][basevar]) {
-      thetensor[num_derivs][basevar] = tensortype;
-      assert (! thevars[num_derivs][basevar]);
-      thevars[num_derivs][basevar]
-        = malloc (tensortype->nvars * sizeof *thevars[num_derivs][basevar]);
-      assert (thevars[num_derivs][basevar]);
+    if (! thetensor[num_derivs][time_level][basevar]) {
+      thetensor[num_derivs][time_level][basevar] = tensortype;
+      assert (! thevars[num_derivs][time_level][basevar]);
+      thevars[num_derivs][time_level][basevar]
+        = malloc (tensortype->nvars
+                  * sizeof *thevars[num_derivs][time_level][basevar]);
+      assert (thevars[num_derivs][time_level][basevar]);
       for (i=0; i<tensortype->nvars; ++i) {
-        thevars[num_derivs][basevar][i] = -1;
+        thevars[num_derivs][time_level][basevar][i] = -1;
       }
     }
-    assert (thetensor[num_derivs][basevar] == tensortype);
-    assert (thevars[num_derivs][basevar]);
-    assert (thevars[num_derivs][basevar][var] == -1);
-    thevars[num_derivs][basevar][var] = m;
+    assert (thetensor[num_derivs][time_level][basevar] == tensortype);
+    assert (thevars[num_derivs][time_level][basevar]);
+    assert (thevars[num_derivs][time_level][basevar][var] == -1);
+    thevars[num_derivs][time_level][basevar][var] = m;
     
   } /* for m */
   
@@ -617,6 +641,7 @@ Rot90_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
   for (m=0; m<N_output_arrays; ++m) {
     
     int num_derivs;
+    int time_level;
     int basevar;
     struct tensor const * restrict tensortype;
     int const * restrict vars;
@@ -634,12 +659,16 @@ Rot90_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
       assert (num_derivs>=0);
     }
     
+    /* Get the time level */
+    time_level = input_array_time_levels[operand_indices[m]];
+    assert (time_level>=0 && time_level<4);
+    
     /* Get the tensor type */
     basevar = thebase[m];
     assert (basevar>=0 && basevar<=CCTK_NumVars());
-    tensortype = thetensor[num_derivs][basevar];
+    tensortype = thetensor[num_derivs][time_level][basevar];
     assert (tensortype);
-    vars = thevars[num_derivs][basevar];
+    vars = thevars[num_derivs][time_level][basevar];
     assert (vars);
     var = thevar[m];
     assert (var>=0 && var<tensortype->nvars);
@@ -732,13 +761,16 @@ Rot90_SymmetryInterpolate (CCTK_POINTER_TO_CONST const cctkGH_,
   }
   free (new_output_arrays);
   
+  free (input_array_time_levels);
   free (operand_indices);
   free (operation_codes);
   free (output_array_indices);
   
   for (q=0; q<3; ++q) {
-    free ((void *) (thetensor[q]));
-    free ((void *) (thevars[q]));
+    for (tl=0; tl<4; ++tl) {
+      free ((void *) (thetensor[q][tl]));
+      free ((void *) (thevars[q][tl]));
+    }
   }
   free (thebase);
   free (thevar);