From 60f3d215793cd3e579cb55ef3be14bb94720ab97 Mon Sep 17 00:00:00 2001
From: Chad Baker <chad.baker@nrel.gov>
Date: Wed, 25 Oct 2023 11:30:28 -0600
Subject: [PATCH 1/9] not sure this is a good path beacuse it cannot reuse the
 derivatives

---
 .../src/simdrive/simdrive_impl.rs             | 81 +++++--------------
 1 file changed, 22 insertions(+), 59 deletions(-)

diff --git a/rust/fastsim-core/src/simdrive/simdrive_impl.rs b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
index 75b2d196..5b4f2b88 100644
--- a/rust/fastsim-core/src/simdrive/simdrive_impl.rs
+++ b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
@@ -976,65 +976,28 @@ impl RustSimDrive {
                 grade_iter += 1;
                 grade = grade_estimate;
 
-                let drag3 = 1.0 / 16.0
-                    * self.props.air_density_kg_per_m3
-                    * self.veh.drag_coef
-                    * self.veh.frontal_area_m2;
-                let accel2 = 0.5 * self.veh.veh_kg / self.cyc.dt_s_at_i(i);
-                let drag2 = 3.0 / 16.0
-                    * self.props.air_density_kg_per_m3
-                    * self.veh.drag_coef
-                    * self.veh.frontal_area_m2
-                    * self.mps_ach[i - 1];
-                let wheel2 = 0.5 * self.veh.wheel_inertia_kg_m2 * self.veh.num_wheels
-                    / (self.cyc.dt_s_at_i(i) * self.veh.wheel_radius_m.powf(2.0));
-                let drag1 = 3.0 / 16.0
-                    * self.props.air_density_kg_per_m3
-                    * self.veh.drag_coef
-                    * self.veh.frontal_area_m2
-                    * self.mps_ach[i - 1].powf(2.0);
-                let roll1 = 0.5
-                    * self.veh.veh_kg
-                    * self.props.a_grav_mps2
-                    * self.veh.wheel_rr_coef
-                    * grade.atan().cos();
-                let ascent1 = 0.5 * self.props.a_grav_mps2 * grade.atan().sin() * self.veh.veh_kg;
-                let accel0 =
-                    -0.5 * self.veh.veh_kg * self.mps_ach[i - 1].powf(2.0) / self.cyc.dt_s_at_i(i);
-                let drag0 = 1.0 / 16.0
-                    * self.props.air_density_kg_per_m3
-                    * self.veh.drag_coef
-                    * self.veh.frontal_area_m2
-                    * self.mps_ach[i - 1].powf(3.0);
-                let roll0 = 0.5
-                    * self.veh.veh_kg
-                    * self.props.a_grav_mps2
-                    * self.veh.wheel_rr_coef
-                    * grade.atan().cos()
-                    * self.mps_ach[i - 1];
-                let ascent0 = 0.5
-                    * self.props.a_grav_mps2
-                    * grade.atan().sin()
-                    * self.veh.veh_kg
-                    * self.mps_ach[i - 1];
-                let wheel0 = -0.5
-                    * self.veh.wheel_inertia_kg_m2
-                    * self.veh.num_wheels
-                    * self.mps_ach[i - 1].powf(2.0)
-                    / (self.cyc.dt_s_at_i(i) * self.veh.wheel_radius_m.powf(2.0));
-
-                let total3 = drag3 / 1e3;
-                let total2 = (accel2 + drag2 + wheel2) / 1e3;
-                let total1 = (drag1 + roll1 + ascent1) / 1e3;
-                let total0 = (accel0 + drag0 + roll0 + ascent0 + wheel0) / 1e3
-                    - self.cur_max_trans_kw_out[i];
-
-                let totals = array![total3, total2, total1, total0];
-
-                let t3 = totals[0];
-                let t2 = totals[1];
-                let t1 = totals[2];
-                let t0 = totals[3];
+                let pwr_err = |speed: f64| -> f64 {
+                    (self.veh.veh_kg
+                        + self.veh.num_wheels * self.veh.wheel_inertia_kg_m2
+                            / self.veh.wheel_radius_m.powi(2))
+                        * (speed.powi(2) - self.mps_ach[i - 1].powi(2))
+                        / (2. * self.cyc.dt_s_at_i(i))
+                        + self.veh.veh_kg * self.props.a_grav_mps2 * (speed + self.mps_ach[i - 1])
+                            / 2.
+                            * ({
+                                let theta = grade;
+                                theta.sin() + grade.atan().cos() * self.veh.wheel_rr_coef
+                            })
+                        + 1. / 16.
+                            * self.props.air_density_kg_per_m3
+                            * self.veh.drag_coef
+                            * self.veh.frontal_area_m2
+                            * (speed.powi(3)
+                                + 3. * speed.powi(2) * self.mps_ach[i - 1]
+                                + self.mps_ach[i - 1].powi(3)
+                                + 3. * speed * self.mps_ach[i - 1].powi(2))
+                };
+
                 // initial guess
                 let xi = max(1.0, self.mps_ach[i - 1]);
                 // stop criteria

From 09392ce50c752b848bf05c0c9d42640dd0317e78 Mon Sep 17 00:00:00 2001
From: Chad Baker <chad.baker@nrel.gov>
Date: Wed, 25 Oct 2023 11:30:34 -0600
Subject: [PATCH 2/9] Revert "not sure this is a good path beacuse it cannot
 reuse the derivatives"

This reverts commit 60f3d215793cd3e579cb55ef3be14bb94720ab97.
---
 .../src/simdrive/simdrive_impl.rs             | 81 ++++++++++++++-----
 1 file changed, 59 insertions(+), 22 deletions(-)

diff --git a/rust/fastsim-core/src/simdrive/simdrive_impl.rs b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
index 5b4f2b88..75b2d196 100644
--- a/rust/fastsim-core/src/simdrive/simdrive_impl.rs
+++ b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
@@ -976,28 +976,65 @@ impl RustSimDrive {
                 grade_iter += 1;
                 grade = grade_estimate;
 
-                let pwr_err = |speed: f64| -> f64 {
-                    (self.veh.veh_kg
-                        + self.veh.num_wheels * self.veh.wheel_inertia_kg_m2
-                            / self.veh.wheel_radius_m.powi(2))
-                        * (speed.powi(2) - self.mps_ach[i - 1].powi(2))
-                        / (2. * self.cyc.dt_s_at_i(i))
-                        + self.veh.veh_kg * self.props.a_grav_mps2 * (speed + self.mps_ach[i - 1])
-                            / 2.
-                            * ({
-                                let theta = grade;
-                                theta.sin() + grade.atan().cos() * self.veh.wheel_rr_coef
-                            })
-                        + 1. / 16.
-                            * self.props.air_density_kg_per_m3
-                            * self.veh.drag_coef
-                            * self.veh.frontal_area_m2
-                            * (speed.powi(3)
-                                + 3. * speed.powi(2) * self.mps_ach[i - 1]
-                                + self.mps_ach[i - 1].powi(3)
-                                + 3. * speed * self.mps_ach[i - 1].powi(2))
-                };
-
+                let drag3 = 1.0 / 16.0
+                    * self.props.air_density_kg_per_m3
+                    * self.veh.drag_coef
+                    * self.veh.frontal_area_m2;
+                let accel2 = 0.5 * self.veh.veh_kg / self.cyc.dt_s_at_i(i);
+                let drag2 = 3.0 / 16.0
+                    * self.props.air_density_kg_per_m3
+                    * self.veh.drag_coef
+                    * self.veh.frontal_area_m2
+                    * self.mps_ach[i - 1];
+                let wheel2 = 0.5 * self.veh.wheel_inertia_kg_m2 * self.veh.num_wheels
+                    / (self.cyc.dt_s_at_i(i) * self.veh.wheel_radius_m.powf(2.0));
+                let drag1 = 3.0 / 16.0
+                    * self.props.air_density_kg_per_m3
+                    * self.veh.drag_coef
+                    * self.veh.frontal_area_m2
+                    * self.mps_ach[i - 1].powf(2.0);
+                let roll1 = 0.5
+                    * self.veh.veh_kg
+                    * self.props.a_grav_mps2
+                    * self.veh.wheel_rr_coef
+                    * grade.atan().cos();
+                let ascent1 = 0.5 * self.props.a_grav_mps2 * grade.atan().sin() * self.veh.veh_kg;
+                let accel0 =
+                    -0.5 * self.veh.veh_kg * self.mps_ach[i - 1].powf(2.0) / self.cyc.dt_s_at_i(i);
+                let drag0 = 1.0 / 16.0
+                    * self.props.air_density_kg_per_m3
+                    * self.veh.drag_coef
+                    * self.veh.frontal_area_m2
+                    * self.mps_ach[i - 1].powf(3.0);
+                let roll0 = 0.5
+                    * self.veh.veh_kg
+                    * self.props.a_grav_mps2
+                    * self.veh.wheel_rr_coef
+                    * grade.atan().cos()
+                    * self.mps_ach[i - 1];
+                let ascent0 = 0.5
+                    * self.props.a_grav_mps2
+                    * grade.atan().sin()
+                    * self.veh.veh_kg
+                    * self.mps_ach[i - 1];
+                let wheel0 = -0.5
+                    * self.veh.wheel_inertia_kg_m2
+                    * self.veh.num_wheels
+                    * self.mps_ach[i - 1].powf(2.0)
+                    / (self.cyc.dt_s_at_i(i) * self.veh.wheel_radius_m.powf(2.0));
+
+                let total3 = drag3 / 1e3;
+                let total2 = (accel2 + drag2 + wheel2) / 1e3;
+                let total1 = (drag1 + roll1 + ascent1) / 1e3;
+                let total0 = (accel0 + drag0 + roll0 + ascent0 + wheel0) / 1e3
+                    - self.cur_max_trans_kw_out[i];
+
+                let totals = array![total3, total2, total1, total0];
+
+                let t3 = totals[0];
+                let t2 = totals[1];
+                let t1 = totals[2];
+                let t0 = totals[3];
                 // initial guess
                 let xi = max(1.0, self.mps_ach[i - 1]);
                 // stop criteria

From 704e5d01f0533493baf86d58ae0eb2963f0277c2 Mon Sep 17 00:00:00 2001
From: Chad Baker <chad.baker@nrel.gov>
Date: Wed, 25 Oct 2023 11:43:08 -0600
Subject: [PATCH 3/9] made `set_ach_speed` more readable

---
 python/fastsim/__init__.py                    | 19 +++--
 python/fastsim/demos/__init__.py              |  4 +
 .../src/simdrive/simdrive_impl.rs             | 75 +++++++++++--------
 3 files changed, 58 insertions(+), 40 deletions(-)

diff --git a/python/fastsim/__init__.py b/python/fastsim/__init__.py
index 4147d7c9..935bcece 100644
--- a/python/fastsim/__init__.py
+++ b/python/fastsim/__init__.py
@@ -6,6 +6,15 @@
 import logging
 import traceback
 
+from . import fastsimrust
+from . import fastsimrust as fsr
+from . import parameters as params
+from . import utilities as utils
+from . import simdrive, vehicle, cycle, calibration, tests
+from . import calibration as cal
+from .resample import resample
+from . import auxiliaries
+
 
 def package_root() -> Path:
     """Returns the package root directory."""
@@ -19,16 +28,6 @@ def package_root() -> Path:
 )
 logger = logging.getLogger(__name__)
 
-
-from . import fastsimrust
-from . import fastsimrust as fsr
-from . import parameters as params
-from . import utilities as utils
-from . import simdrive, vehicle, cycle, calibration, tests
-from . import calibration as cal
-from .resample import resample
-from . import auxiliaries
-
 from pkg_resources import get_distribution
 
 __version__ = get_distribution("fastsim").version
diff --git a/python/fastsim/demos/__init__.py b/python/fastsim/demos/__init__.py
index e69de29b..13d6283f 100644
--- a/python/fastsim/demos/__init__.py
+++ b/python/fastsim/demos/__init__.py
@@ -0,0 +1,4 @@
+print(
+    "Module `fastsim.demos` has been imported.  This should only " 
+    + "happen during testing so you might be doing something wrong."
+)
\ No newline at end of file
diff --git a/rust/fastsim-core/src/simdrive/simdrive_impl.rs b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
index 75b2d196..32fd7110 100644
--- a/rust/fastsim-core/src/simdrive/simdrive_impl.rs
+++ b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
@@ -1023,53 +1023,68 @@ impl RustSimDrive {
                     * self.mps_ach[i - 1].powf(2.0)
                     / (self.cyc.dt_s_at_i(i) * self.veh.wheel_radius_m.powf(2.0));
 
-                let total3 = drag3 / 1e3;
-                let total2 = (accel2 + drag2 + wheel2) / 1e3;
-                let total1 = (drag1 + roll1 + ascent1) / 1e3;
-                let total0 = (accel0 + drag0 + roll0 + ascent0 + wheel0) / 1e3
+                let t3 = drag3 / 1e3;
+                let t2 = (accel2 + drag2 + wheel2) / 1e3;
+                let t1 = (drag1 + roll1 + ascent1) / 1e3;
+                let t0 = (accel0 + drag0 + roll0 + ascent0 + wheel0) / 1e3
                     - self.cur_max_trans_kw_out[i];
 
-                let totals = array![total3, total2, total1, total0];
-
-                let t3 = totals[0];
-                let t2 = totals[1];
-                let t1 = totals[2];
-                let t0 = totals[3];
                 // initial guess
-                let xi = max(1.0, self.mps_ach[i - 1]);
+                let speed_guess = max(1.0, self.mps_ach[i - 1]);
                 // stop criteria
                 let max_iter = self.sim_params.newton_max_iter;
                 let xtol = self.sim_params.newton_xtol;
                 // solver gain
                 let g = self.sim_params.newton_gain;
-                let yi = t3 * xi.powf(3.0) + t2 * xi.powf(2.0) + t1 * xi + t0;
-                let mi = 3.0 * t3 * xi.powf(2.0) + 2.0 * t2 * xi + t1;
-                let bi = yi - xi * mi;
-                let mut xs = vec![xi];
-                let mut ys = vec![yi];
-                let mut ms = vec![mi];
-                let mut bs = vec![bi];
+                let pwr_err =
+                    t3 * speed_guess.powf(3.0) + t2 * speed_guess.powf(2.0) + t1 * speed_guess + t0;
+                let d_pwr_err_per_d_speed_guess =
+                    3.0 * t3 * speed_guess.powf(2.0) + 2.0 * t2 * speed_guess + t1;
+                let new_speed_guess = pwr_err - speed_guess * d_pwr_err_per_d_speed_guess;
+                let mut speed_guesses = vec![speed_guess];
+                let mut pwr_errs = vec![pwr_err];
+                let mut d_pwr_err_per_d_speed_guesses = vec![d_pwr_err_per_d_speed_guess];
+                let mut new_speed_guesses = vec![new_speed_guess];
                 let mut iterate = 1;
                 let mut converged = false;
                 while iterate < max_iter && !converged {
-                    let xi = xs[xs.len() - 1] * (1.0 - g) - g * bs[xs.len() - 1] / ms[xs.len() - 1];
-                    let yi = t3 * xi.powf(3.0) + t2 * xi.powf(2.0) + t1 * xi + t0;
-                    let mi = 3.0 * t3 * xi.powf(2.0) + 2.0 * t2 * xi + t1;
-                    let bi = yi - xi * mi;
-                    xs.push(xi);
-                    ys.push(yi);
-                    ms.push(mi);
-                    bs.push(bi);
-                    converged =
-                        ((xs[xs.len() - 1] - xs[xs.len() - 2]) / xs[xs.len() - 2]).abs() < xtol;
+                    let speed_guess = speed_guesses
+                        .iter()
+                        .last()
+                        .ok_or(anyhow!("{}", format_dbg!()))?
+                        * (1.0 - g)
+                        - g * new_speed_guesses
+                            .iter()
+                            .last()
+                            .ok_or(anyhow!("{}", format_dbg!()))?
+                            / d_pwr_err_per_d_speed_guesses[speed_guesses.len() - 1];
+                    let pwr_err = t3 * speed_guess.powf(3.0)
+                        + t2 * speed_guess.powf(2.0)
+                        + t1 * speed_guess
+                        + t0;
+                    let d_pwr_err_per_d_speed_guess =
+                        3.0 * t3 * speed_guess.powf(2.0) + 2.0 * t2 * speed_guess + t1;
+                    let new_speed_guess = pwr_err - speed_guess * d_pwr_err_per_d_speed_guess;
+                    speed_guesses.push(speed_guess);
+                    pwr_errs.push(pwr_err);
+                    d_pwr_err_per_d_speed_guesses.push(d_pwr_err_per_d_speed_guess);
+                    new_speed_guesses.push(new_speed_guess);
+                    converged = ((speed_guesses
+                        .iter()
+                        .last()
+                        .ok_or(anyhow!("{}", format_dbg!()))?
+                        - speed_guesses[speed_guesses.len() - 2])
+                        / speed_guesses[speed_guesses.len() - 2])
+                        .abs()
+                        < xtol;
                     iterate += 1;
                 }
 
                 self.newton_iters[i] = iterate;
 
-                let _ys = Array::from_vec(ys).map(|x| x.abs());
+                let _ys = Array::from_vec(pwr_errs).map(|x| x.abs());
                 self.mps_ach[i] = max(
-                    xs[_ys
+                    speed_guesses[_ys
                         .iter()
                         .position(|&x| x == ndarrmin(&_ys))
                         .ok_or_else(|| anyhow!(format_dbg!(ndarrmin(&_ys))))?],

From 4d2940343be0eaa13f5bc89802203740e698c501 Mon Sep 17 00:00:00 2001
From: Chad Baker <chad.baker@nrel.gov>
Date: Wed, 25 Oct 2023 11:50:25 -0600
Subject: [PATCH 4/9] specified resolver

---
 rust/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index 234b4de9..1d2c1ffe 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -1,4 +1,5 @@
 [workspace]
+resolver = "2"
 
 members = [
     "fastsim-cli",                      # command line app

From ac043779ab2317d34ccac74d41aaa5a44414b6e3 Mon Sep 17 00:00:00 2001
From: Chad Baker <chad.baker@nrel.gov>
Date: Wed, 25 Oct 2023 12:06:38 -0600
Subject: [PATCH 5/9] added closures in `set_ach_speed` for more efficient code

---
 .../src/simdrive/simdrive_impl.rs             | 39 ++++++++++---------
 rust/fastsim-core/src/simdrivelabel.rs        |  7 +++-
 2 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/rust/fastsim-core/src/simdrive/simdrive_impl.rs b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
index 32fd7110..9cbb1401 100644
--- a/rust/fastsim-core/src/simdrive/simdrive_impl.rs
+++ b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
@@ -1036,18 +1036,23 @@ impl RustSimDrive {
                 let xtol = self.sim_params.newton_xtol;
                 // solver gain
                 let g = self.sim_params.newton_gain;
-                let pwr_err =
-                    t3 * speed_guess.powf(3.0) + t2 * speed_guess.powf(2.0) + t1 * speed_guess + t0;
-                let d_pwr_err_per_d_speed_guess =
-                    3.0 * t3 * speed_guess.powf(2.0) + 2.0 * t2 * speed_guess + t1;
-                let new_speed_guess = pwr_err - speed_guess * d_pwr_err_per_d_speed_guess;
+                let pwr_err_fn = |speed_guess: f64| -> f64 {
+                    t3 * speed_guess.powf(3.0) + t2 * speed_guess.powf(2.0) + t1 * speed_guess + t0
+                };
+                let pwr_err_per_speed_guess_fn = |speed_guess: f64| -> f64 {
+                    3.0 * t3 * speed_guess.powf(2.0) + 2.0 * t2 * speed_guess + t1
+                };
+                let pwr_err = pwr_err_fn(speed_guess);
+                let pwr_err_per_speed_guess = pwr_err_per_speed_guess_fn(speed_guess);
+                let new_speed_guess = pwr_err - speed_guess * pwr_err_per_speed_guess;
                 let mut speed_guesses = vec![speed_guess];
                 let mut pwr_errs = vec![pwr_err];
-                let mut d_pwr_err_per_d_speed_guesses = vec![d_pwr_err_per_d_speed_guess];
+                let mut d_pwr_err_per_d_speed_guesses = vec![pwr_err_per_speed_guess];
                 let mut new_speed_guesses = vec![new_speed_guess];
-                let mut iterate = 1;
+                // speed achieved iteration counter
+                let mut spd_ach_i = 1;
                 let mut converged = false;
-                while iterate < max_iter && !converged {
+                while spd_ach_i < max_iter && !converged {
                     let speed_guess = speed_guesses
                         .iter()
                         .last()
@@ -1058,16 +1063,12 @@ impl RustSimDrive {
                             .last()
                             .ok_or(anyhow!("{}", format_dbg!()))?
                             / d_pwr_err_per_d_speed_guesses[speed_guesses.len() - 1];
-                    let pwr_err = t3 * speed_guess.powf(3.0)
-                        + t2 * speed_guess.powf(2.0)
-                        + t1 * speed_guess
-                        + t0;
-                    let d_pwr_err_per_d_speed_guess =
-                        3.0 * t3 * speed_guess.powf(2.0) + 2.0 * t2 * speed_guess + t1;
-                    let new_speed_guess = pwr_err - speed_guess * d_pwr_err_per_d_speed_guess;
+                    let pwr_err = pwr_err_fn(speed_guess);
+                    let pwr_err_per_speed_guess = pwr_err_per_speed_guess_fn(speed_guess);
+                    let new_speed_guess = pwr_err - speed_guess * pwr_err_per_speed_guess;
                     speed_guesses.push(speed_guess);
                     pwr_errs.push(pwr_err);
-                    d_pwr_err_per_d_speed_guesses.push(d_pwr_err_per_d_speed_guess);
+                    d_pwr_err_per_d_speed_guesses.push(pwr_err_per_speed_guess);
                     new_speed_guesses.push(new_speed_guess);
                     converged = ((speed_guesses
                         .iter()
@@ -1077,12 +1078,14 @@ impl RustSimDrive {
                         / speed_guesses[speed_guesses.len() - 2])
                         .abs()
                         < xtol;
-                    iterate += 1;
+                    spd_ach_i += 1;
                 }
 
-                self.newton_iters[i] = iterate;
+                self.newton_iters[i] = spd_ach_i;
 
                 let _ys = Array::from_vec(pwr_errs).map(|x| x.abs());
+                // Question: could we assume `speed_guesses.iter().last()` is the correct solution?
+                // This would make for faster running.
                 self.mps_ach[i] = max(
                     speed_guesses[_ys
                         .iter()
diff --git a/rust/fastsim-core/src/simdrivelabel.rs b/rust/fastsim-core/src/simdrivelabel.rs
index 4515a598..2932c690 100644
--- a/rust/fastsim-core/src/simdrivelabel.rs
+++ b/rust/fastsim-core/src/simdrivelabel.rs
@@ -803,7 +803,12 @@ mod simdrivelabel_tests {
         //     100. * (label_fe_truth.net_accel - label_fe.net_accel) / label_fe_truth.net_accel
         // );
 
-        assert!(label_fe.approx_eq(&label_fe_truth, 1e-10));
+        assert!(
+            label_fe.approx_eq(&label_fe_truth, 1e-10),
+            "label_fe:\n{}\n\nlabel_fe_truth:\n{}",
+            label_fe.to_json(),
+            label_fe_truth.to_json()
+        );
     }
     #[test]
     fn test_get_label_fe_phev() {

From 0a4b848acaf2a672d93d8d8dfd495415311757f8 Mon Sep 17 00:00:00 2001
From: Chad Baker <chad.baker@nrel.gov>
Date: Wed, 25 Oct 2023 12:07:46 -0600
Subject: [PATCH 6/9] addressed some warnings

---
 .../src/simdrive/simdrive_impl.rs             | 25 ++++---------------
 1 file changed, 5 insertions(+), 20 deletions(-)

diff --git a/rust/fastsim-core/src/simdrive/simdrive_impl.rs b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
index 9cbb1401..b8e8bcb1 100644
--- a/rust/fastsim-core/src/simdrive/simdrive_impl.rs
+++ b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
@@ -632,20 +632,11 @@ impl RustSimDrive {
             }
         }
         // Is SOC below min threshold?
-        if self.soc[i - 1] < (self.veh.min_soc + self.veh.perc_high_acc_buf) {
-            self.reached_buff[i] = false;
-        } else {
-            self.reached_buff[i] = true;
-        }
+        self.reached_buff[i] = self.soc[i - 1] >= (self.veh.min_soc + self.veh.perc_high_acc_buf);
 
         // Does the engine need to be on for low SOC or high acceleration
-        if self.soc[i - 1] < self.veh.min_soc
-            || (self.high_acc_fc_on_tag[i - 1] && !(self.reached_buff[i]))
-        {
-            self.high_acc_fc_on_tag[i] = true
-        } else {
-            self.high_acc_fc_on_tag[i] = false
-        }
+        self.high_acc_fc_on_tag[i] = self.soc[i - 1] < self.veh.min_soc
+            || (self.high_acc_fc_on_tag[i - 1] && !(self.reached_buff[i]));
         self.max_trac_mps[i] =
             self.mps_ach[i - 1] + (self.veh.max_trac_mps2 * self.cyc.dt_s_at_i(i));
         Ok(())
@@ -1350,14 +1341,8 @@ impl RustSimDrive {
     pub fn set_fc_forced_state_rust(&mut self, i: usize) -> Result<(), anyhow::Error> {
         // force fuel converter on if it was on in the previous time step, but only if fc
         // has not been on longer than minFcTimeOn
-        if self.prev_fc_time_on[i] > 0.0
-            && self.prev_fc_time_on[i] < self.veh.min_fc_time_on - self.cyc.dt_s_at_i(i)
-        {
-            self.fc_forced_on[i] = true;
-        } else {
-            self.fc_forced_on[i] = false
-        }
-
+        self.fc_forced_on[i] = self.prev_fc_time_on[i] > 0.0
+            && self.prev_fc_time_on[i] < self.veh.min_fc_time_on - self.cyc.dt_s_at_i(i);
         if !self.fc_forced_on[i] || !self.can_pwr_all_elec[i] {
             // fc forced on because:
             // - it was on in the previous time step and hasn't been on long enough

From fa4dd0a9d50b2e1ca338549a2cb1a586fc405675 Mon Sep 17 00:00:00 2001
From: Chad Baker <chad.baker@nrel.gov>
Date: Wed, 25 Oct 2023 14:38:32 -0600
Subject: [PATCH 7/9] replaced `powf` with faster `powi`

---
 .../src/add_pyo3_api/mod.rs                   |  1 -
 .../src/simdrive/simdrive_impl.rs             | 38 +++++++++----------
 2 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/rust/fastsim-core/fastsim-proc-macros/src/add_pyo3_api/mod.rs b/rust/fastsim-core/fastsim-proc-macros/src/add_pyo3_api/mod.rs
index 48c9625b..3df85e7a 100644
--- a/rust/fastsim-core/fastsim-proc-macros/src/add_pyo3_api/mod.rs
+++ b/rust/fastsim-core/fastsim-proc-macros/src/add_pyo3_api/mod.rs
@@ -205,7 +205,6 @@ pub fn add_pyo3_api(attr: TokenStream, item: TokenStream) -> TokenStream {
                     });
                 }
             }
-        } else {
         }
     } else {
         abort_call_site!("`add_pyo3_api` works only on named and tuple structs.");
diff --git a/rust/fastsim-core/src/simdrive/simdrive_impl.rs b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
index b8e8bcb1..483c756d 100644
--- a/rust/fastsim-core/src/simdrive/simdrive_impl.rs
+++ b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
@@ -862,10 +862,10 @@ impl RustSimDrive {
             * self.props.air_density_kg_per_m3
             * self.veh.drag_coef
             * self.veh.frontal_area_m2
-            * ((self.mps_ach[i - 1] + mps_ach) / 2.0).powf(3.0)
+            * ((self.mps_ach[i - 1] + mps_ach) / 2.0).powi(3)
             / 1e3;
         self.accel_kw[i] = self.veh.veh_kg / (2.0 * self.cyc.dt_s_at_i(i))
-            * (mps_ach.powf(2.0) - self.mps_ach[i - 1].powf(2.0))
+            * (mps_ach.powi(2) - self.mps_ach[i - 1].powi(2))
             / 1e3;
         self.ascent_kw[i] = self.props.a_grav_mps2
             * grade.atan().sin()
@@ -886,12 +886,12 @@ impl RustSimDrive {
         self.cyc_tire_inertia_kw[i] = (0.5
             * self.veh.wheel_inertia_kg_m2
             * self.veh.num_wheels
-            * self.cyc_whl_rad_per_sec[i].powf(2.0)
+            * self.cyc_whl_rad_per_sec[i].powi(2)
             / self.cyc.dt_s_at_i(i)
             - 0.5
                 * self.veh.wheel_inertia_kg_m2
                 * self.veh.num_wheels
-                * (self.mps_ach[i - 1] / self.veh.wheel_radius_m).powf(2.0)
+                * (self.mps_ach[i - 1] / self.veh.wheel_radius_m).powi(2)
                 / self.cyc.dt_s_at_i(i))
             / 1e3;
 
@@ -978,12 +978,12 @@ impl RustSimDrive {
                     * self.veh.frontal_area_m2
                     * self.mps_ach[i - 1];
                 let wheel2 = 0.5 * self.veh.wheel_inertia_kg_m2 * self.veh.num_wheels
-                    / (self.cyc.dt_s_at_i(i) * self.veh.wheel_radius_m.powf(2.0));
+                    / (self.cyc.dt_s_at_i(i) * self.veh.wheel_radius_m.powi(2));
                 let drag1 = 3.0 / 16.0
                     * self.props.air_density_kg_per_m3
                     * self.veh.drag_coef
                     * self.veh.frontal_area_m2
-                    * self.mps_ach[i - 1].powf(2.0);
+                    * self.mps_ach[i - 1].powi(2);
                 let roll1 = 0.5
                     * self.veh.veh_kg
                     * self.props.a_grav_mps2
@@ -991,12 +991,12 @@ impl RustSimDrive {
                     * grade.atan().cos();
                 let ascent1 = 0.5 * self.props.a_grav_mps2 * grade.atan().sin() * self.veh.veh_kg;
                 let accel0 =
-                    -0.5 * self.veh.veh_kg * self.mps_ach[i - 1].powf(2.0) / self.cyc.dt_s_at_i(i);
+                    -0.5 * self.veh.veh_kg * self.mps_ach[i - 1].powi(2) / self.cyc.dt_s_at_i(i);
                 let drag0 = 1.0 / 16.0
                     * self.props.air_density_kg_per_m3
                     * self.veh.drag_coef
                     * self.veh.frontal_area_m2
-                    * self.mps_ach[i - 1].powf(3.0);
+                    * self.mps_ach[i - 1].powi(3);
                 let roll0 = 0.5
                     * self.veh.veh_kg
                     * self.props.a_grav_mps2
@@ -1011,8 +1011,8 @@ impl RustSimDrive {
                 let wheel0 = -0.5
                     * self.veh.wheel_inertia_kg_m2
                     * self.veh.num_wheels
-                    * self.mps_ach[i - 1].powf(2.0)
-                    / (self.cyc.dt_s_at_i(i) * self.veh.wheel_radius_m.powf(2.0));
+                    * self.mps_ach[i - 1].powi(2)
+                    / (self.cyc.dt_s_at_i(i) * self.veh.wheel_radius_m.powi(2));
 
                 let t3 = drag3 / 1e3;
                 let t2 = (accel2 + drag2 + wheel2) / 1e3;
@@ -1028,10 +1028,10 @@ impl RustSimDrive {
                 // solver gain
                 let g = self.sim_params.newton_gain;
                 let pwr_err_fn = |speed_guess: f64| -> f64 {
-                    t3 * speed_guess.powf(3.0) + t2 * speed_guess.powf(2.0) + t1 * speed_guess + t0
+                    t3 * speed_guess.powi(3) + t2 * speed_guess.powi(2) + t1 * speed_guess + t0
                 };
                 let pwr_err_per_speed_guess_fn = |speed_guess: f64| -> f64 {
-                    3.0 * t3 * speed_guess.powf(2.0) + 2.0 * t2 * speed_guess + t1
+                    3.0 * t3 * speed_guess.powi(2) + 2.0 * t2 * speed_guess + t1
                 };
                 let pwr_err = pwr_err_fn(speed_guess);
                 let pwr_err_per_speed_guess = pwr_err_per_speed_guess_fn(speed_guess);
@@ -1113,7 +1113,7 @@ impl RustSimDrive {
                 (self.veh.ess_max_kwh * self.veh.max_soc
                     - 0.5
                         * self.veh.veh_kg
-                        * (self.cyc.mps[i].powf(2.0))
+                        * (self.cyc.mps[i].powi(2))
                         * (1.0 / 1_000.0)
                         * (1.0 / 3_600.0)
                         * self.veh.mc_peak_eff()
@@ -1145,9 +1145,9 @@ impl RustSimDrive {
         } else {
             self.accel_buff_soc[i] = min(
                 max(
-                    ((self.veh.max_accel_buffer_mph / params::MPH_PER_MPS).powf(2.0)
-                        - self.cyc.mps[i].powf(2.0))
-                        / (self.veh.max_accel_buffer_mph / params::MPH_PER_MPS).powf(2.0)
+                    ((self.veh.max_accel_buffer_mph / params::MPH_PER_MPS).powi(2)
+                        - self.cyc.mps[i].powi(2))
+                        / (self.veh.max_accel_buffer_mph / params::MPH_PER_MPS).powi(2)
                         * min(
                             self.veh.max_accel_buffer_perc_of_useable_soc
                                 * (self.veh.max_soc - self.veh.min_soc),
@@ -1849,12 +1849,12 @@ impl RustSimDrive {
                 .mps_ach
                 .first()
                 .ok_or_else(|| anyhow!(format_dbg!(self.mps_ach)))?
-                .powf(2.0)
+                .powi(2)
                 - self
                     .mps_ach
                     .last()
                     .ok_or_else(|| anyhow!(format_dbg!(self.mps_ach)))?
-                    .powf(2.0))
+                    .powi(2))
             / 1_000.0;
 
         self.energy_audit_error =
@@ -1870,7 +1870,7 @@ impl RustSimDrive {
         }
         for i in 1..self.cyc.len() {
             self.accel_kw[i] = self.veh.veh_kg / (2.0 * self.cyc.dt_s_at_i(i))
-                * (self.mps_ach[i].powf(2.0) - self.mps_ach[i - 1].powf(2.0))
+                * (self.mps_ach[i].powi(2) - self.mps_ach[i - 1].powi(2))
                 / 1_000.0;
         }
 

From 0ab3273fd7d16ecb833ecb8929515107d4dbf0ef Mon Sep 17 00:00:00 2001
From: Chad Baker <chad.baker@nrel.gov>
Date: Wed, 25 Oct 2023 14:48:25 -0600
Subject: [PATCH 8/9] refactored for fewer repeat calculations

---
 rust/fastsim-core/src/simdrive/simdrive_impl.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/rust/fastsim-core/src/simdrive/simdrive_impl.rs b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
index 483c756d..90ee4268 100644
--- a/rust/fastsim-core/src/simdrive/simdrive_impl.rs
+++ b/rust/fastsim-core/src/simdrive/simdrive_impl.rs
@@ -886,13 +886,9 @@ impl RustSimDrive {
         self.cyc_tire_inertia_kw[i] = (0.5
             * self.veh.wheel_inertia_kg_m2
             * self.veh.num_wheels
-            * self.cyc_whl_rad_per_sec[i].powi(2)
-            / self.cyc.dt_s_at_i(i)
-            - 0.5
-                * self.veh.wheel_inertia_kg_m2
-                * self.veh.num_wheels
-                * (self.mps_ach[i - 1] / self.veh.wheel_radius_m).powi(2)
-                / self.cyc.dt_s_at_i(i))
+            * (self.cyc_whl_rad_per_sec[i].powi(2)
+                - (self.mps_ach[i - 1] / self.veh.wheel_radius_m).powi(2))
+            / self.cyc.dt_s_at_i(i))
             / 1e3;
 
         self.cyc_whl_kw_req[i] =

From b2a5c048d94b74692a9f55e66180d1dc5ca9ff84 Mon Sep 17 00:00:00 2001
From: Chad Baker <calbaker@users.noreply.github.com>
Date: Thu, 2 Nov 2023 14:42:51 -0600
Subject: [PATCH 9/9] changed print to warning

Co-authored-by: Kyle Carow <40699307+kylecarow@users.noreply.github.com>
---
 python/fastsim/demos/__init__.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/python/fastsim/demos/__init__.py b/python/fastsim/demos/__init__.py
index 13d6283f..7ef80a6a 100644
--- a/python/fastsim/demos/__init__.py
+++ b/python/fastsim/demos/__init__.py
@@ -1,4 +1,7 @@
-print(
-    "Module `fastsim.demos` has been imported.  This should only " 
-    + "happen during testing so you might be doing something wrong."
+import logging
+
+logger = logging.getLogger(__name__)
+logger.warning(
+    "Module `fastsim.demos` has been imported. This should only "
+    + "happen during testing, so you might be doing something wrong."
 )
\ No newline at end of file