Requirements: Modify iteration arguments in Requirements.hh

Use int instead of CCTK_INT; all other arguments are also int.
Change argument order in Sync; move iteration next to reflevel.
Add iteration argument to BeforeRoutine; AfterRoutine also takes it.
Change name from cctk_iteration to iteration; no other variables have a cctk_ prefix.

Update callers in Carpet.

4 files changed, 41 insertions, 36 deletions

diff --git a/Carpet/Requirements/src/Requirements.cc b/Carpet/Requirements/src/Requirements.cc
index b496d5049..d4a9dfd3c 100644
--- a/Carpet/Requirements/src/Requirements.cc
+++ b/Carpet/Requirements/src/Requirements.cc
@@ -142,13 +142,14 @@ namespace Requirements {
   }
    
   void BeforeRoutine(cFunctionData const* const function_data,
-                     int const reflevel, int const map,
+                     int const iteration, int const reflevel, int const map,
                      int const timelevel, int const timelevel_offset)
   {
     DECLARE_CCTK_PARAMETERS;
     if (check_requirements) {
       all_state.before_routine(function_data, all_clauses,
-                               reflevel, map, timelevel, timelevel_offset);
+                               iteration, reflevel, map,
+                               timelevel, timelevel_offset);
     }
     if (inconsistencies_are_fatal and gridpoint_t::there_was_an_error) {
       CCTK_WARN(CCTK_WARN_ABORT,
@@ -156,14 +157,15 @@ namespace Requirements {
     }
   }
   
-  void AfterRoutine(cFunctionData const* const function_data, CCTK_INT cctk_iteration,
-                    int const reflevel, int const map,
+  void AfterRoutine(cFunctionData const* const function_data,
+                    int const iteration, int const reflevel, int const map,
                     int const timelevel, int const timelevel_offset)
   {
     DECLARE_CCTK_PARAMETERS;
     if (check_requirements) {
-      all_state.after_routine(function_data, all_clauses, cctk_iteration,
-                              reflevel, map, timelevel, timelevel_offset);
+      all_state.after_routine(function_data, all_clauses,
+                              iteration, reflevel, map,
+                              timelevel, timelevel_offset);
     }
     if (inconsistencies_are_fatal and gridpoint_t::there_was_an_error) {
       CCTK_WARN(CCTK_WARN_ABORT,
@@ -172,9 +174,8 @@ namespace Requirements {
   }
   
   void Sync(cFunctionData const* const function_data,
-            CCTK_INT cctk_iteration,
             vector<int> const& groups,
-            int const reflevel, int const timelevel)
+            int const iteration, int const reflevel, int const timelevel)
   {
     DECLARE_CCTK_PARAMETERS;
     if (check_requirements) {
@@ -183,7 +184,7 @@ namespace Requirements {
                    "Sync reflevel=%d timelevel=%d",
                    reflevel, timelevel);
       }
-      all_state.sync(function_data, cctk_iteration, groups, reflevel, timelevel);
+      all_state.sync(function_data, groups, iteration, reflevel, timelevel);
     }
     if (inconsistencies_are_fatal and gridpoint_t::there_was_an_error) {
       CCTK_WARN(CCTK_WARN_ABORT,
@@ -191,7 +192,8 @@ namespace Requirements {
     }
   }
   
-  void Restrict(vector<int> const& groups, CCTK_INT const cctk_iteration, int const reflevel)
+  void Restrict(vector<int> const& groups,
+                int const iteration, int const reflevel)
   {
     DECLARE_CCTK_PARAMETERS;
     if (check_requirements) {
@@ -200,7 +202,7 @@ namespace Requirements {
                    "Restrict reflevel=%d",
                    reflevel);
       }
-      all_state.restrict1(groups, cctk_iteration, reflevel);
+      all_state.restrict1(groups, iteration, reflevel);
     }
     if (inconsistencies_are_fatal and gridpoint_t::there_was_an_error) {
       CCTK_WARN(CCTK_WARN_ABORT,
@@ -244,7 +246,8 @@ namespace Requirements {
         temp_function_data.ReadsClauses = (char const**)&reads;
         all_clauses.get_clauses(&temp_function_data);
         BeforeRoutine(&temp_function_data,
-                      reflevel, map, timelevel, timelevel_offset);
+                      cctkGH->cctk_iteration, reflevel, map,
+                      timelevel, timelevel_offset);
         all_clauses.remove_clauses(&temp_function_data);
         free(fullname);
         free(reads);
@@ -285,8 +288,9 @@ namespace Requirements {
         temp_function_data.n_ReadsClauses = 0;
         temp_function_data.ReadsClauses = NULL;
         all_clauses.get_clauses(&temp_function_data);
-        AfterRoutine(&temp_function_data, cctkGH->cctk_iteration,
-                     reflevel, map, timelevel, timelevel_offset);
+        AfterRoutine(&temp_function_data,
+                     cctkGH->cctk_iteration, reflevel, map,
+                     timelevel, timelevel_offset);
         all_clauses.remove_clauses(&temp_function_data);
         free(fullname);
         free(writes);
diff --git a/Carpet/Requirements/src/Requirements.hh b/Carpet/Requirements/src/Requirements.hh
index a82093ce1..8c682f6dd 100644
--- a/Carpet/Requirements/src/Requirements.hh
+++ b/Carpet/Requirements/src/Requirements.hh
@@ -42,20 +42,20 @@ namespace Requirements {
   // TODO: Either combine these "before" and "after" routines, or
   // split the other routines as well
   void BeforeRoutine(cFunctionData const* function_data,
-                     int reflevel, int map,
+                     int iteration, int reflevel, int map,
                      int timelevel, int timelevel_offset);
   // After calling a routine: update according to writes clauses
   void AfterRoutine(cFunctionData const* function_data,
-                    CCTK_INT cctk_iteration,
-                    int reflevel, int map,
+                    int iteration, int reflevel, int map,
                     int timelevel, int timelevel_offset);
   // Synchronise and prolongate
   // TODO: This does not handle variables that are not prolongated
   // TODO: This does not handle buffer zones
-  void Sync(cFunctionData const* function_data, CCTK_INT cctk_iteration,
-            vector<int> const& groups, int reflevel, int timelevel);
+  void Sync(cFunctionData const* function_data,
+            vector<int> const& groups,
+            int iteration, int reflevel, int timelevel);
   // Restrict
-  void Restrict(vector<int> const& groups, CCTK_INT cctk_iteration, int reflevel);
+  void Restrict(vector<int> const& groups, int iteration, int reflevel);
   
 } // namespace Requirements
 
diff --git a/Carpet/Requirements/src/all_state.cc b/Carpet/Requirements/src/all_state.cc
index bb1e4c40f..1a7d10dab 100644
--- a/Carpet/Requirements/src/all_state.cc
+++ b/Carpet/Requirements/src/all_state.cc
@@ -347,6 +347,7 @@ namespace Requirements {
   // function is executed
   void all_state_t::before_routine(cFunctionData const* const function_data,
                                    all_clauses_t &all_clauses,
+                                   int const iteration,
                                    int const reflevel, int const map,
                                    int const timelevel,
                                    int const timelevel_offset)
@@ -417,7 +418,7 @@ namespace Requirements {
   // executed to reflect the fact that some variables are now valid
   void all_state_t::after_routine(cFunctionData const* const function_data,
                                   all_clauses_t &all_clauses,
-                                  CCTK_INT cctk_iteration,
+                                  int const iteration,
                                   int const reflevel, int const map,
                                   int const timelevel,
                                   int const timelevel_offset)
@@ -430,7 +431,7 @@ namespace Requirements {
     info += " in ";
     info += function_data->where;
     loc.info = info.c_str();
-    loc.it = cctk_iteration;
+    loc.it = iteration;
     // Loop over all clauses
     clauses_t const& clauses = all_clauses.get_clauses(function_data);
     for (vector<clause_t>::const_iterator iclause = clauses.writes.begin();
@@ -455,8 +456,8 @@ namespace Requirements {
           min_rl = reflevel; max_rl = min_rl+1;
         }
         for (int rl=min_rl; rl<max_rl; ++rl) {
-          
           loc.rl = rl;
+          
           maps_t& ms = rls.AT(rl);
           int const maps = int(ms.size());
           int min_m, max_m;
@@ -498,15 +499,15 @@ namespace Requirements {
   
   // Update internal data structures when Carpet syncs
   void all_state_t::sync(cFunctionData const* const function_data,
-                         CCTK_INT cctk_iteration,
                          vector<int> const& groups,
+                         int const iteration,
                          int const reflevel, int const timelevel)
   {
     location_t loc;
     loc.info = "sync";
+    loc.it = iteration;
     loc.rl = reflevel;
     loc.tl = timelevel;
-    loc.it = cctk_iteration;
     // Loop over all variables
     for (vector<int>::const_iterator
            igi = groups.begin(); igi != groups.end(); ++igi)
@@ -533,18 +534,17 @@ namespace Requirements {
         int const v0 = CCTK_FirstVarIndexI(gi);
         int const nv = CCTK_NumVarsInGroupI(gi);
         for (int vi=v0; vi<v0+nv; ++vi) {
-          if (ignored_variables.AT(vi))
-            continue;
+          if (ignored_variables.AT(vi)) continue;
           loc.vi = vi;
           
           reflevels_t& rls = vars.AT(vi);
           maps_t& ms = rls.AT(rl);
           int const maps = int(ms.size());
           for (int m=0; m<maps; ++m) {
+            loc.m = m;
             timelevels_t& tls = ms.AT(m);
             int const tl = timelevel;
             gridpoint_t& gp = tls.AT(tl);
-            loc.m = m;
             
             // Synchronising requires a valid interior
             if (not gp.interior()) {
@@ -598,12 +598,13 @@ namespace Requirements {
 
 
   // Update internal data structures when Carpet restricts
-  void all_state_t::restrict1(vector<int> const& groups, CCTK_INT const cctk_iteration, int const reflevel)
+  void all_state_t::restrict1(vector<int> const& groups,
+                              int const iteration, int const reflevel)
   {
     location_t loc;
     loc.info = "restrict";
+    loc.it = iteration;
     loc.rl = reflevel;
-    loc.it = cctk_iteration;
     // Loop over all variables
     for (vector<int>::const_iterator
            igi = groups.begin(); igi != groups.end(); ++igi)
diff --git a/Carpet/Requirements/src/all_state.hh b/Carpet/Requirements/src/all_state.hh
index fff6a437a..78f03fc83 100644
--- a/Carpet/Requirements/src/all_state.hh
+++ b/Carpet/Requirements/src/all_state.hh
@@ -40,16 +40,16 @@ namespace Requirements {
     void cycle(int reflevel);
     void before_routine(cFunctionData const* function_data,
                         all_clauses_t &all_clauses,
-                        int reflevel, int map,
+                        int iteration, int reflevel, int map,
                         int timelevel, int timelevel_offset) const;
     void after_routine(cFunctionData const* function_data,
                        all_clauses_t &all_clauses,
-                       CCTK_INT cctk_iteration,
-                       int reflevel, int map,
+                       int iteration, int reflevel, int map,
                        int timelevel, int timelevel_offset);
-    void sync(cFunctionData const* function_data, CCTK_INT cctk_iteration,
-              vector<int> const& groups, int reflevel, int timelevel);
-    void restrict1(vector<int> const& groups, CCTK_INT cctk_iteration, int reflevel);
+    void sync(cFunctionData const* function_data,
+              vector<int> const& groups, 
+              int iteration, int reflevel, int timelevel);
+    void restrict1(vector<int> const& groups, int iteration, int reflevel);
     void invalidate(vector<int> const& vars,
                     int reflevel, int map, int timelevel);