From 5884e649202f2e7a30fd0a40150dfa5bced5babb Mon Sep 17 00:00:00 2001
From: "Penn, John M 047828115" <john.m.penn@nasa.gov>
Date: Mon, 5 Oct 2020 14:16:50 -0500
Subject: [PATCH] Refactoring: eliminate assumption that independent variable
 is time. #1058

---
 .../DoubleIntegral/DoubleIntegral.cpp         |   8 +-
 .../SAIntegrator/include/SAIntegrator.hh      |  52 +++---
 .../SAIntegrator/src/SAIntegrator.cpp         | 164 +++++++++---------
 .../unittest/SAIntegrator_unittest.cc         |  17 +-
 4 files changed, 125 insertions(+), 116 deletions(-)

diff --git a/trick_source/trick_utils/SAIntegrator/examples/DoubleIntegral/DoubleIntegral.cpp b/trick_source/trick_utils/SAIntegrator/examples/DoubleIntegral/DoubleIntegral.cpp
index 33e5480b..91822b07 100644
--- a/trick_source/trick_utils/SAIntegrator/examples/DoubleIntegral/DoubleIntegral.cpp
+++ b/trick_source/trick_utils/SAIntegrator/examples/DoubleIntegral/DoubleIntegral.cpp
@@ -21,8 +21,8 @@ void deriv_x( double x, double state_x[], double derivs_x[], void* udata) {
     SA::RK2Integrator* integ_y = context->integ;
     integ_y->set_in_vars(state_y);
     integ_y->set_out_vars(state_y);
-    integ_y->setTime(context->start);
-    while (integ_y->getTime() <= context->end) {
+    integ_y->setIndyVar(context->start);
+    while (integ_y->getIndyVar() <= context->end) {
         integ_y->load();
         integ_y->step();
         integ_y->unload();
@@ -38,8 +38,8 @@ double doubleIntegral( double x_start, double x_end, double y_start, double y_en
     SA::RK2Integrator integ_y (dy, 2, NULL, NULL, deriv_y, NULL);
     IContext y_integ_context = {&integ_y, y_start, y_end};
     SA::RK2Integrator integ_x (dx, 1, state_x, state_x, deriv_x, &y_integ_context);
-    integ_x.setTime(x_start);
-    while (integ_x.getTime()<=x_end) { // x-end
+    integ_x.setIndyVar(x_start);
+    while (integ_x.getIndyVar()<=x_end) {
         integ_x.load();
         integ_x.step();
         integ_x.unload();
diff --git a/trick_source/trick_utils/SAIntegrator/include/SAIntegrator.hh b/trick_source/trick_utils/SAIntegrator/include/SAIntegrator.hh
index f58b170c..41f41614 100644
--- a/trick_source/trick_utils/SAIntegrator/include/SAIntegrator.hh
+++ b/trick_source/trick_utils/SAIntegrator/include/SAIntegrator.hh
@@ -3,20 +3,22 @@ namespace SA {
 
     class Integrator {
     protected:
-        double time;
-        double default_dt;
-        void * udata;
+        double indyVar;     // Independent Variable
+        double default_h;   // Default step-size
+        void * udata;       // User data
     public:
-        Integrator(double dt, void* user_data): time(0.0), default_dt(dt), udata(user_data) {};
+        Integrator(double h, void* user_data): indyVar(0.0), default_h(h), udata(user_data) {};
         virtual ~Integrator() {}
-        virtual void step() { time += default_dt; }; // Integrate over implicit (default) time step (default: default_dt)
+        virtual void step() { indyVar += default_h; }; // Integrate over default step-size (default_h)
         virtual void load() = 0;
         virtual void unload() = 0;
-        double getTime() {return time;}
-        void setTime(double t) {time = t;}
+        double getIndyVar() {return indyVar;}
+        void setIndyVar(double t) {indyVar = t;}
+        double getTime() {return indyVar;}
+        void setTime(double t) {indyVar = t;}
     };
 
-    typedef void (*derivsFunc)( double t, double state[], double derivs[], void* user_data);
+    typedef void (*derivsFunc)( double x, double state[], double derivs[], void* user_data);
 
     class FirstOrderODEIntegrator : public Integrator {
     protected:
@@ -28,10 +30,10 @@ namespace SA {
         derivsFunc derivs_func;
 
         bool reset;
-        double last_dt; // What was the last step-size? For undo_step().
+        double last_h; // What was the last step-size? For undo_step().
 
     public:
-        FirstOrderODEIntegrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data);
+        FirstOrderODEIntegrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data);
         ~FirstOrderODEIntegrator();
         virtual void undo_step();
         void load();
@@ -43,17 +45,17 @@ namespace SA {
     class FirstOrderODEVariableStepIntegrator : public FirstOrderODEIntegrator {
 
     public:
-        FirstOrderODEVariableStepIntegrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data);
+        FirstOrderODEVariableStepIntegrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data);
         using Integrator::step;
-        virtual void step( double dt );
+        virtual void step( double h );
     };
 
     class EulerIntegrator : public FirstOrderODEVariableStepIntegrator {
         public:
         double *derivs;
-        EulerIntegrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
+        EulerIntegrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
         ~EulerIntegrator();
-        void step( double dt);
+        void step( double h);
         void step();
     };
 
@@ -62,9 +64,9 @@ namespace SA {
         double *wstate;
         double *derivs[2];
 
-        HeunsMethod( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
+        HeunsMethod( double h, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
         ~HeunsMethod();
-        void step( double dt);
+        void step( double h);
         void step();
     };
 
@@ -73,9 +75,9 @@ namespace SA {
         double *wstate;
         double *derivs[2];
 
-        RK2Integrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
+        RK2Integrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
         ~RK2Integrator();
-        void step( double dt);
+        void step( double h);
         void step();
     };
 
@@ -84,9 +86,9 @@ namespace SA {
         double *wstate[3];
         double *derivs[4];
 
-        RK4Integrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
+        RK4Integrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
         ~RK4Integrator();
-        void step( double dt);
+        void step( double h);
         void step();
 
     };
@@ -96,9 +98,9 @@ namespace SA {
         double *wstate[4];
         double *derivs[4];
 
-        RK3_8Integrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
+        RK3_8Integrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
         ~RK3_8Integrator();
-        void step( double dt);
+        void step( double h);
         void step();
 
     };
@@ -137,7 +139,7 @@ namespace SA {
     //     unsigned int currentHistorySize;
     //
     // public:
-    //     ABMIntegrator(int history_size, double dt, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
+    //     ABMIntegrator(int history_size, double h, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
     //     ~ABMIntegrator();
     //     void step();
     //     void undo_step();
@@ -154,7 +156,7 @@ namespace SA {
         FirstOrderODEVariableStepIntegrator* priming_integrator;
 
     public:
-        ABM2Integrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
+        ABM2Integrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
         ~ABM2Integrator();
         void step();
         void undo_step();
@@ -171,7 +173,7 @@ namespace SA {
         FirstOrderODEVariableStepIntegrator* priming_integrator;
 
     public:
-        ABM4Integrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
+        ABM4Integrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc derivs_func, void* user_data);
         ~ABM4Integrator();
         void step();
         void undo_step();
diff --git a/trick_source/trick_utils/SAIntegrator/src/SAIntegrator.cpp b/trick_source/trick_utils/SAIntegrator/src/SAIntegrator.cpp
index 7e1abf85..e9ae2659 100644
--- a/trick_source/trick_utils/SAIntegrator/src/SAIntegrator.cpp
+++ b/trick_source/trick_utils/SAIntegrator/src/SAIntegrator.cpp
@@ -5,8 +5,8 @@
 
 // ------------------------------------------------------------
 
-SA::FirstOrderODEIntegrator::FirstOrderODEIntegrator(double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
-: Integrator(dt, user_data) {
+SA::FirstOrderODEIntegrator::FirstOrderODEIntegrator(double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
+: Integrator(h, user_data) {
     state_size = N;
     orig_vars = in_vars;
     dest_vars = out_vars;
@@ -49,45 +49,45 @@ void SA::FirstOrderODEIntegrator::undo_step() {
         for (int i=0 ; i<state_size; i++ ) {
             *(orig_vars[i]) = istate[i]; // Copy istate values back to the state variables from whence they came.
         }
-        time -= last_dt;                    // Undo the last time-step.
+        indyVar -= last_h;    // Undo the last step.
     }
     reset = true;
 }
 
 // ------------------------------------------------------------
 
-SA::FirstOrderODEVariableStepIntegrator::FirstOrderODEVariableStepIntegrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
-: FirstOrderODEIntegrator(dt, N, in_vars, out_vars, func, user_data) {}
+SA::FirstOrderODEVariableStepIntegrator::FirstOrderODEVariableStepIntegrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
+: FirstOrderODEIntegrator(h, N, in_vars, out_vars, func, user_data) {}
 
-void SA::FirstOrderODEVariableStepIntegrator::step( double dt ) {
-     last_dt = dt; time += dt;
+void SA::FirstOrderODEVariableStepIntegrator::step( double h ) {
+     last_h = h; indyVar += h;
 }
 
 // ------------------------------------------------------------
 
-SA::EulerIntegrator::EulerIntegrator(double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
-    : FirstOrderODEVariableStepIntegrator(dt, N, in_vars, out_vars, func, user_data)
+SA::EulerIntegrator::EulerIntegrator(double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
+    : FirstOrderODEVariableStepIntegrator(h, N, in_vars, out_vars, func, user_data)
 {
     derivs = new double[N];
 }
 SA::EulerIntegrator::~EulerIntegrator() {
     delete derivs;
 }
-void SA::EulerIntegrator::step( double dt) {
-    (*derivs_func)( time, istate, derivs, udata);
+void SA::EulerIntegrator::step( double h) {
+    (*derivs_func)( indyVar, istate, derivs, udata);
     for (unsigned int i=0; i<state_size; i++) {
-        ostate[i] = istate[i] + derivs[i] * dt;
+        ostate[i] = istate[i] + derivs[i] * h;
     }
-    SA::FirstOrderODEVariableStepIntegrator::step(dt);
+    SA::FirstOrderODEVariableStepIntegrator::step(h);
 }
 void SA::EulerIntegrator::step() {
-    step(default_dt);
+    step(default_h);
 }
 
 // ------------------------------------------------------------
 
-SA::HeunsMethod::HeunsMethod( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
-    : FirstOrderODEVariableStepIntegrator(dt, N, in_vars, out_vars, func, user_data)
+SA::HeunsMethod::HeunsMethod( double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
+    : FirstOrderODEVariableStepIntegrator(h, N, in_vars, out_vars, func, user_data)
 {
     wstate = new double[N];
     for (unsigned int i = 0; i < 2 ; i++) {
@@ -100,25 +100,25 @@ SA::HeunsMethod::~HeunsMethod() {
         delete derivs[i];
     }
 }
-void SA::HeunsMethod::step( double dt) {
-    (*derivs_func)( time, istate, derivs[0], udata);
+void SA::HeunsMethod::step( double h) {
+    (*derivs_func)( indyVar, istate, derivs[0], udata);
     for (unsigned int i=0; i<state_size; i++) {
-        wstate[i] = istate[i] + dt * derivs[0][i];
+        wstate[i] = istate[i] + h * derivs[0][i];
     }
-    (*derivs_func)( time, wstate, derivs[1], udata);
+    (*derivs_func)( indyVar, wstate, derivs[1], udata);
     for (unsigned int i=0; i<state_size; i++) {
-        ostate[i] = istate[i] + (dt/2) * ( derivs[0][i] +  derivs[1][i] );
+        ostate[i] = istate[i] + (h/2) * ( derivs[0][i] +  derivs[1][i] );
     }
-    SA::FirstOrderODEVariableStepIntegrator::step(dt);
+    SA::FirstOrderODEVariableStepIntegrator::step(h);
 }
 void SA::HeunsMethod::step() {
-    step(default_dt);
+    step(default_h);
 }
 
 // ------------------------------------------------------------
 
-SA::RK2Integrator::RK2Integrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
-    : FirstOrderODEVariableStepIntegrator(dt, N, in_vars, out_vars, func, user_data)
+SA::RK2Integrator::RK2Integrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
+    : FirstOrderODEVariableStepIntegrator(h, N, in_vars, out_vars, func, user_data)
 {
     wstate = new double[N];
     for (unsigned int i = 0; i < 2 ; i++) {
@@ -131,25 +131,25 @@ SA::RK2Integrator::~RK2Integrator() {
         delete derivs[i];
     }
 }
-void SA::RK2Integrator::step( double dt) {
-    (*derivs_func)( time, istate, derivs[0], udata);
+void SA::RK2Integrator::step( double h) {
+    (*derivs_func)( indyVar, istate, derivs[0], udata);
     for (unsigned int i=0; i<state_size; i++) {
-        wstate[i] = istate[i] + 0.5 * dt * derivs[0][i];
+        wstate[i] = istate[i] + 0.5 * h * derivs[0][i];
     }
-    (*derivs_func)( time + 0.5 * dt , wstate, derivs[1], udata);
+    (*derivs_func)( indyVar + 0.5 * h , wstate, derivs[1], udata);
     for (unsigned int i=0; i<state_size; i++) {
-        ostate[i] = istate[i] + dt * derivs[1][i];
+        ostate[i] = istate[i] + h * derivs[1][i];
     }
-    SA::FirstOrderODEVariableStepIntegrator::step(dt);
+    SA::FirstOrderODEVariableStepIntegrator::step(h);
 }
 void SA::RK2Integrator::step() {
-    step(default_dt);
+    step(default_h);
 }
 
 // ------------------------------------------------------------
 
-SA::RK4Integrator::RK4Integrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
-    : FirstOrderODEVariableStepIntegrator(dt, N, in_vars, out_vars, func, user_data)
+SA::RK4Integrator::RK4Integrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
+    : FirstOrderODEVariableStepIntegrator(h, N, in_vars, out_vars, func, user_data)
 {
     for (unsigned int i = 0; i < 3 ; i++) {
         wstate[i] = new double[N];
@@ -166,36 +166,36 @@ SA::RK4Integrator::~RK4Integrator() {
         delete (derivs[i]);
     }
 }
-void SA::RK4Integrator::step( double dt) {
-    (*derivs_func)( time, istate, derivs[0], udata);
+void SA::RK4Integrator::step( double h) {
+    (*derivs_func)( indyVar, istate, derivs[0], udata);
     for (unsigned int i=0; i<state_size; i++) {
-        wstate[0][i] = istate[i] + 0.5 * derivs[0][i] * dt;
+        wstate[0][i] = istate[i] + 0.5 * derivs[0][i] * h;
     }
-    (*derivs_func)( time + 0.5 * dt , wstate[0], derivs[1], udata);
+    (*derivs_func)( indyVar + 0.5 * h , wstate[0], derivs[1], udata);
     for (unsigned int i=0; i<state_size; i++) {
-        wstate[1][i] = istate[i] + 0.5 * derivs[1][i] * dt;
+        wstate[1][i] = istate[i] + 0.5 * derivs[1][i] * h;
     }
-    (*derivs_func)( time + 0.5 * dt , wstate[1], derivs[2], udata);
+    (*derivs_func)( indyVar + 0.5 * h , wstate[1], derivs[2], udata);
     for (unsigned int i=0; i<state_size; i++) {
-        wstate[2][i] = istate[i] + derivs[2][i] * dt;
+        wstate[2][i] = istate[i] + derivs[2][i] * h;
     }
-    (*derivs_func)( time + dt , wstate[2], derivs[3], udata);
+    (*derivs_func)( indyVar + h , wstate[2], derivs[3], udata);
     for (unsigned int i=0; i<state_size; i++) {
         ostate[i] = istate[i] + ((1/6.0)* derivs[0][i] +
                                  (1/3.0)* derivs[1][i] +
                                  (1/3.0)* derivs[2][i] +
-                                 (1/6.0)* derivs[3][i]) * dt;
+                                 (1/6.0)* derivs[3][i]) * h;
     }
-    SA::FirstOrderODEVariableStepIntegrator::step(dt);
+    SA::FirstOrderODEVariableStepIntegrator::step(h);
 }
 void SA::RK4Integrator::step() {
-    step(default_dt);
+    step(default_h);
 }
 
 // ------------------------------------------------------------
 
-SA::RK3_8Integrator::RK3_8Integrator( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
-    : FirstOrderODEVariableStepIntegrator(dt, N, in_vars, out_vars ,func, user_data)
+SA::RK3_8Integrator::RK3_8Integrator( double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
+    : FirstOrderODEVariableStepIntegrator(h, N, in_vars, out_vars ,func, user_data)
 {
     for (unsigned int i = 0; i < 3 ; i++) {
         wstate[i] = new double[N];
@@ -212,30 +212,30 @@ SA::RK3_8Integrator::~RK3_8Integrator() {
         delete (derivs[i]);
     }
 }
-void SA::RK3_8Integrator::step( double dt) {
-    (*derivs_func)( time, istate, derivs[0], udata);
+void SA::RK3_8Integrator::step( double h) {
+    (*derivs_func)( indyVar, istate, derivs[0], udata);
     for (unsigned int i=0; i<state_size; i++) {
-        wstate[0][i] = istate[i] + dt * (1/3.0) * derivs[0][i];
+        wstate[0][i] = istate[i] + h * (1/3.0) * derivs[0][i];
     }
-    (*derivs_func)( time + (1/3.0) * dt , wstate[0], derivs[1], udata);
+    (*derivs_func)( indyVar + (1/3.0) * h , wstate[0], derivs[1], udata);
     for (unsigned int i=0; i<state_size; i++) {
-        wstate[1][i] = istate[i] + dt * ((-1/3.0) * derivs[0][i] + derivs[1][i]);
+        wstate[1][i] = istate[i] + h * ((-1/3.0) * derivs[0][i] + derivs[1][i]);
     }
-    (*derivs_func)( time + (2/3.0) * dt , wstate[1], derivs[2], udata);
+    (*derivs_func)( indyVar + (2/3.0) * h , wstate[1], derivs[2], udata);
     for (unsigned int i=0; i<state_size; i++) {
-        wstate[2][i] = istate[i] + dt * (derivs[0][i] - derivs[1][i] + derivs[2][i]);
+        wstate[2][i] = istate[i] + h * (derivs[0][i] - derivs[1][i] + derivs[2][i]);
     }
-    (*derivs_func)( time + dt , wstate[2], derivs[3], udata);
+    (*derivs_func)( indyVar + h , wstate[2], derivs[3], udata);
     for (unsigned int i=0; i<state_size; i++) {
         ostate[i] = istate[i] + ((1/8.0)* derivs[0][i] +
                                  (3/8.0)* derivs[1][i] +
                                  (3/8.0)* derivs[2][i] +
-                                 (1/8.0)* derivs[3][i]) * dt;
+                                 (1/8.0)* derivs[3][i]) * h;
     }
-    SA::FirstOrderODEVariableStepIntegrator::step(dt);
+    SA::FirstOrderODEVariableStepIntegrator::step(h);
 }
 void SA::RK3_8Integrator::step() {
-    step(default_dt);
+    step(default_h);
 }
 
 // ------------------------------------------------------------
@@ -269,18 +269,18 @@ SA::EulerCromerIntegrator::~EulerCromerIntegrator() {
     delete v_out;
 }
 void SA::EulerCromerIntegrator::step( double dt) {
-    (*gderivs)( time, x_in, g_out, udata);
+    (*gderivs)( indyVar, x_in, g_out, udata);
     for (int i=0 ; i<state_size; i++ ) {
         v_out[i] = v_in[i] + g_out[i] * dt;
     }
-    (*fderivs)( time, v_in, f_out, udata);
+    (*fderivs)( indyVar, v_in, f_out, udata);
     for (int i=0 ; i<state_size; i++ ) {
         x_out[i] = x_in[i] + f_out[i] * dt;
     }
-    time += dt;
+    indyVar += dt;
 }
 void SA::EulerCromerIntegrator::step() {
-    step(default_dt);
+    step(default_h);
 }
 void SA::EulerCromerIntegrator::load() {
     for (int i=0 ; i<state_size; i++ ) {
@@ -312,8 +312,8 @@ void SA::EulerCromerIntegrator::unload(){
 //   {(9/24.0),    (19/24.0),   (-5/24.0),    (1/24.0),     0.0},
 //   {(251/720.0), (646/720.0), (-264/720.0), (106/720.0), (-19/720.0)}
 // };
-// SA::ABMIntegrator::ABMIntegrator ( int history_size, double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
-//     : FirstOrderODEIntegrator(dt, N, in_vars, out_vars ,func, user_data) {
+// SA::ABMIntegrator::ABMIntegrator ( int history_size, double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
+//     : FirstOrderODEIntegrator(h, N, in_vars, out_vars ,func, user_data) {
 //
 //     algorithmHistorySize=history_size; // The amount of history that we intend to use in this ABM integrator.
 //     bufferSize=algorithmHistorySize+1; // The size of the buffer needs to be one more than the history so that an integration step can be reset.
@@ -335,7 +335,7 @@ void SA::EulerCromerIntegrator::unload(){
 // void SA::ABMIntegrator::step() {
 //
 //     hix = (hix+1)%bufferSize;                          // Move history index forward
-//     (*derivs_func)( time, istate, deriv_history[hix], udata); // Calculated and store the deriv for current, corrected state.
+//     (*derivs_func)( indyVar, istate, deriv_history[hix], udata); // Calculated and store the deriv for current, corrected state.
 //     // Increase the size of the stored history, up to the limit specified by the user.
 //     currentHistorySize = (currentHistorySize < algorithmHistorySize) ? currentHistorySize+1 : algorithmHistorySize;
 //     // (Predictor) Predict the next state using the Adams-Bashforth explicit method.
@@ -344,19 +344,19 @@ void SA::EulerCromerIntegrator::unload(){
 //         for (int n=0,j=hix; n<currentHistorySize ; n++,j=(j+bufferSize-1)%bufferSize) {
 //             composite_deriv[i] += ABCoeffs[currentHistorySize-1][n] * deriv_history[j][i];
 //         }
-//         ostate[i] = istate[i] + default_dt * composite_deriv[i];
+//         ostate[i] = istate[i] + default_h * composite_deriv[i];
 //     }
 //     // Move history index forward, so we can temporarily store the derivative of the predicted next state.
 //     // We do not increase the currentHistorySize.
 //     hix = (hix+1)%bufferSize;
-//     (*derivs_func)( time, ostate, deriv_history[hix], udata); // Calc deriv for predicted next state.
+//     (*derivs_func)( indyVar, ostate, deriv_history[hix], udata); // Calc deriv for predicted next state.
 //     // (Corrector) Refine the next state using the Adams-Moulton implicit method. This is the corrected next state.
 //     for (int i=0; i<state_size; i++) {
 //         composite_deriv[i] = 0.0;
 //         for (int n=0,j=hix; n<currentHistorySize ; n++,j=(j+bufferSize-1)%bufferSize) {
 //             composite_deriv[i] += AMCoeffs[currentHistorySize-1][n] * deriv_history[j][i];
 //         }
-//         ostate[i] = istate[i] + default_dt * composite_deriv[i];
+//         ostate[i] = istate[i] + default_h * composite_deriv[i];
 //     }
 //     // Move history index backward, so we over-write the predicted state with the corrected state on our next step().
 //     hix = (hix+bufferSize-1)%bufferSize;
@@ -372,8 +372,8 @@ void SA::EulerCromerIntegrator::unload(){
 static const double AB2Coeffs[2] = {(3/2.0), (-1/2.0)};
 static const double AM2Coeffs[2] = {(1/2.0),  (1/2.0)};
 
-SA::ABM2Integrator::ABM2Integrator ( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
-    : FirstOrderODEIntegrator(dt, N, in_vars, out_vars ,func, user_data) {
+SA::ABM2Integrator::ABM2Integrator ( double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
+    : FirstOrderODEIntegrator(h, N, in_vars, out_vars ,func, user_data) {
     // The amount of history that we intend to use in this ABM integrator.
     bufferSize=2+1; // The size of the buffer needs to be one more than the history so that an integration step can be reset.
     hix=0;
@@ -393,7 +393,7 @@ SA::ABM2Integrator::ABM2Integrator ( double dt, int N, double* in_vars[], double
     for (unsigned int i=0; i<N ; i++) {
         priming_integrator_out_vars[i] = &(ostate[i]);
     }
-    priming_integrator = new SA::RK2Integrator(dt, N, priming_integrator_in_vars, priming_integrator_out_vars, func, user_data);
+    priming_integrator = new SA::RK2Integrator(h, N, priming_integrator_in_vars, priming_integrator_out_vars, func, user_data);
 }
 SA::ABM2Integrator::~ABM2Integrator() {
     for (int i=0; i<bufferSize ; i++) {
@@ -406,7 +406,7 @@ SA::ABM2Integrator::~ABM2Integrator() {
 void SA::ABM2Integrator::step() {
 
     hix = (hix+1)%bufferSize;                          // Move history index forward
-    (*derivs_func)( time, istate, deriv_history[hix], udata); // Calculated and store the deriv for current, corrected state.
+    (*derivs_func)( indyVar, istate, deriv_history[hix], udata); // Calculated and store the deriv for current, corrected state.
     // Increase the size of the stored history, up to the limit specified by the user.
     currentHistorySize = (currentHistorySize < 2) ? currentHistorySize+1 : 2;
 
@@ -421,19 +421,19 @@ void SA::ABM2Integrator::step() {
             for (int n=0,j=hix; n<2 ; n++,j=(j+bufferSize-1)%bufferSize) {
                 composite_deriv[i] += AB2Coeffs[n] * deriv_history[j][i];
             }
-            ostate[i] = istate[i] + default_dt * composite_deriv[i];
+            ostate[i] = istate[i] + default_h * composite_deriv[i];
         }
         // Move history index forward, so we can temporarily store the derivative of the predicted next state.
         // We do not increase the currentHistorySize.
         hix = (hix+1)%bufferSize;
-        (*derivs_func)( time, ostate, deriv_history[hix], udata); // Calc deriv for predicted next state.
+        (*derivs_func)( indyVar, ostate, deriv_history[hix], udata); // Calc deriv for predicted next state.
         // (Corrector) Refine the next state using the Adams-Moulton implicit method. This is the corrected next state.
         for (int i=0; i<state_size; i++) {
             composite_deriv[i] = 0.0;
             for (int n=0,j=hix; n<2 ; n++,j=(j+bufferSize-1)%bufferSize) {
                 composite_deriv[i] += AM2Coeffs[n] * deriv_history[j][i];
             }
-            ostate[i] = istate[i] + default_dt * composite_deriv[i];
+            ostate[i] = istate[i] + default_h * composite_deriv[i];
         }
         // Move history index backward, so we over-write the predicted state with the corrected state on our next step().
         hix = (hix+bufferSize-1)%bufferSize;
@@ -449,8 +449,8 @@ void SA::ABM2Integrator::undo_step() {
 static const double AB4Coeffs[4] = {(55/24.0), (-59/24.0), (37/24.0), (-9/24.0)};
 static const double AM4Coeffs[4] = {(9/24.0), (19/24.0), (-5/24.0), (1/24.0)};
 
-SA::ABM4Integrator::ABM4Integrator ( double dt, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
-    : FirstOrderODEIntegrator(dt, N, in_vars, out_vars ,func, user_data) {
+SA::ABM4Integrator::ABM4Integrator ( double h, int N, double* in_vars[], double* out_vars[], derivsFunc func, void* user_data)
+    : FirstOrderODEIntegrator(h, N, in_vars, out_vars ,func, user_data) {
 
     // The amount of history that we intend to use in this ABM integrator.
     bufferSize=4+1; // The size of the buffer needs to be one more than the history so that an integration step can be reset.
@@ -471,7 +471,7 @@ SA::ABM4Integrator::ABM4Integrator ( double dt, int N, double* in_vars[], double
     for (unsigned int i=0; i<N ; i++) {
         priming_integrator_out_vars[i] = &(ostate[i]);
     }
-    priming_integrator = new SA::RK4Integrator(dt, N, priming_integrator_in_vars, priming_integrator_out_vars, func, user_data);
+    priming_integrator = new SA::RK4Integrator(h, N, priming_integrator_in_vars, priming_integrator_out_vars, func, user_data);
 }
 
 SA::ABM4Integrator::~ABM4Integrator() {
@@ -486,7 +486,7 @@ SA::ABM4Integrator::~ABM4Integrator() {
 void SA::ABM4Integrator::step() {
 
     hix = (hix+1)%bufferSize;                          // Move history index forward
-    (*derivs_func)( time, istate, deriv_history[hix], udata); // Calculated and store the deriv for current, corrected state.
+    (*derivs_func)( indyVar, istate, deriv_history[hix], udata); // Calculated and store the deriv for current, corrected state.
     // Increase the size of the stored history, up to the limit specified by the user.
     currentHistorySize = (currentHistorySize < 4) ? currentHistorySize+1 : 4;
     if ( currentHistorySize < 4 ) {
@@ -500,19 +500,19 @@ void SA::ABM4Integrator::step() {
             for (int n=0,j=hix; n<4 ; n++,j=(j+bufferSize-1)%bufferSize) {
                 composite_deriv[i] += AB4Coeffs[n] * deriv_history[j][i];
             }
-            ostate[i] = istate[i] + default_dt * composite_deriv[i];
+            ostate[i] = istate[i] + default_h * composite_deriv[i];
         }
         // Move history index forward, so we can temporarily store the derivative of the predicted next state.
         // We do not increase the currentHistorySize.
         hix = (hix+1)%bufferSize;
-        (*derivs_func)( time, ostate, deriv_history[hix], udata); // Calc deriv for predicted next state.
+        (*derivs_func)( indyVar, ostate, deriv_history[hix], udata); // Calc deriv for predicted next state.
         // (Corrector) Refine the next state using the Adams-Moulton implicit method. This is the corrected next state.
         for (int i=0; i<state_size; i++) {
             composite_deriv[i] = 0.0;
             for (int n=0,j=hix; n<4 ; n++,j=(j+bufferSize-1)%bufferSize) {
                 composite_deriv[i] += AM4Coeffs[n] * deriv_history[j][i];
             }
-            ostate[i] = istate[i] + default_dt * composite_deriv[i];
+            ostate[i] = istate[i] + default_h * composite_deriv[i];
         }
         // Move history index backward, so we over-write the predicted state with the corrected state on our next step().
         hix = (hix+bufferSize-1)%bufferSize;
diff --git a/trick_source/trick_utils/SAIntegrator/unittest/SAIntegrator_unittest.cc b/trick_source/trick_utils/SAIntegrator/unittest/SAIntegrator_unittest.cc
index 59ef1175..3234385b 100644
--- a/trick_source/trick_utils/SAIntegrator/unittest/SAIntegrator_unittest.cc
+++ b/trick_source/trick_utils/SAIntegrator/unittest/SAIntegrator_unittest.cc
@@ -3,17 +3,22 @@
 #include "SAIntegrator.hh"
 #include <math.h>
 
-void deriv4( double t, double state[], double derivs[], void* udata) {
+void deriv4( double t,
+             double state[] __attribute__((unused)),
+             double derivs[],
+             void* udata __attribute__((unused))) {
     double t2 = t*t;
     double t3 = t2*t;
-
     derivs[0] = 3.0*t3 - 3.0*t2 - 3.0*t +  4.0;
     derivs[1] = 2.0*t3 + 1.0*t2 - 5.0*t +  7.0;
     derivs[2] =     t3 +     t2 + 5.0*t +  4.0;
     derivs[3] =     t3 - 6.0*t2 + 4.0*t + 12.0;
 }
 
-void deriv2( double t, double state[], double derivs[], void* udata) {
+void deriv2( double t,
+             double state[] __attribute__((unused)),
+             double derivs[],
+             void* udata __attribute__((unused))) {
 
     derivs[0] = -2.0*t + 3.0;
     derivs[1] =  5.0*t + 4.0;
@@ -21,8 +26,10 @@ void deriv2( double t, double state[], double derivs[], void* udata) {
     derivs[3] =  5.0*t + 4.0;
 }
 
-void deriv1( double t, double state[], double derivs[], void* udata) {
-
+void deriv1( double t __attribute__((unused)),
+             double state[] __attribute__((unused)),
+             double derivs[],
+             void* udata __attribute__((unused))) {
     derivs[0] = 4.0;
     derivs[1] = -4.0;
     derivs[2] = M_PI;