Serde revamp and anyhowization

rust/fastsim-cli/Cargo.toml

@@ -12,6 +12,7 @@ repository = "https://github.com/NREL/fastsim"
 
 [dependencies]
 fastsim-core = { path = "../fastsim-core", version = "~0" }
+anyhow = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 project-root = "0.2.2"

rust/fastsim-cli/src/bin/fastsim-cli.rs

@@ -120,9 +120,9 @@ pub fn calculate_mpgge_for_h2_diesel_ice(
     fs_kwh_out_ach: &Vec<f64>,
     fc_pwr_out_perc: &Vec<f64>,
     h2share: &Vec<f64>,
-) -> H2AndDieselResults {
-    assert!(fc_kw_out_ach.len() == fs_kwh_out_ach.len());
-    assert!(fc_pwr_out_perc.len() == h2share.len());
+) -> anyhow::Result<H2AndDieselResults> {
+    anyhow::ensure!(fc_kw_out_ach.len() == fs_kwh_out_ach.len());
+    anyhow::ensure!(fc_pwr_out_perc.len() == h2share.len());
     let kwh_per_gallon_diesel = 37.95;
     let gge_per_kwh = 1.0 / kwh_per_gge;
     let mut total_diesel_kwh = 0.0;
@@ -148,7 +148,7 @@ pub fn calculate_mpgge_for_h2_diesel_ice(
         total_diesel_gals += diesel_gals;
         total_diesel_gge += diesel_gge;
     }
-    H2AndDieselResults {
+    Ok(H2AndDieselResults {
         h2_kwh: total_h2_kwh,
         h2_gge: total_h2_gge,
         h2_mpgge: if total_h2_gge > 0.0 {
@@ -164,25 +164,25 @@ pub fn calculate_mpgge_for_h2_diesel_ice(
         } else {
             0.0
         },
-    }
+    })
 }
 
-pub fn integrate_power_to_kwh(dts_s: &Vec<f64>, ps_kw: &Vec<f64>) -> Vec<f64> {
-    assert!(dts_s.len() == ps_kw.len());
+pub fn integrate_power_to_kwh(dts_s: &Vec<f64>, ps_kw: &Vec<f64>) -> anyhow::Result<Vec<f64>> {
+    anyhow::ensure!(dts_s.len() == ps_kw.len());
     let mut energy_kwh = Vec::<f64>::with_capacity(dts_s.len());
     for idx in 0..dts_s.len() {
         let dt_s = dts_s[idx];
         let p_kw = ps_kw[idx];
         energy_kwh.push(p_kw * dt_s / 3600.0);
     }
-    energy_kwh
+    Ok(energy_kwh)
 }
 
-pub fn main() {
+pub fn main() -> anyhow::Result<()> {
     let fastsim_api = FastSimApi::parse();
 
     if let Some(_cyc_json_str) = fastsim_api.cyc {
-        panic!("Need to implement: let cyc = RustCycle::from_json(cyc_json_str)");
+        anyhow::bail!("Need to implement: let cyc = RustCycle::from_json(cyc_json_str)");
     }
     let (is_adopt_hd, adopt_hd_string, adopt_hd_has_cycle) =
         if let Some(adopt_hd_string) = &fastsim_api.adopt_hd {
@@ -215,26 +215,25 @@ pub fn main() {
                 );
                 println!("Drag Coefficient: {}", drag_coeff);
                 println!("Wheel RR Coefficient: {}", wheel_rr_coeff);
-                return;
+                return Ok(());
             } else {
-                panic!("Need to provide coastdown test coefficients for drag and wheel rr coefficient calculation");
+                anyhow::bail!("Need to provide coastdown test coefficients for drag and wheel rr coefficient calculation");
             }
         } else {
             RustCycle::from_file(&cyc_file_path)
         }
     } else if is_adopt_hd && adopt_hd_has_cycle {
-        RustCycle::from_file(&adopt_hd_string)
+        RustCycle::from_file(adopt_hd_string)
     } else {
         //TODO? use pathbuff to string, for robustness
         Ok(RustCycle::new(
             vec![0.0],
             vec![0.0],
             vec![0.0],
             vec![0.0],
-            String::from("")
+            String::from(""),
         ))
-    }
-    .unwrap();
+    }?;
 
     // TODO: put in logic here for loading vehicle for adopt-hd
     // with same file format as regular adopt and same outputs retured
@@ -243,44 +242,35 @@ pub fn main() {
     let mut hd_h2_diesel_ice_h2share: Option<Vec<f64>> = None;
     let veh = if let Some(veh_string) = fastsim_api.veh {
         if is_adopt || is_adopt_hd {
-            let (veh_string, pwr_out_perc, h2share) = json_rewrite(veh_string);
+            let (veh_string, pwr_out_perc, h2share) = json_rewrite(veh_string)?;
             hd_h2_diesel_ice_h2share = h2share;
             fc_pwr_out_perc = pwr_out_perc;
-            RustVehicle::from_json_str(&veh_string)
+            let mut veh = RustVehicle::from_json(&veh_string)?;
+            veh.set_derived()?;
+            Ok(veh)
         } else {
-            RustVehicle::from_json_str(&veh_string)
+            let mut veh = RustVehicle::from_json(&veh_string)?;
+            veh.set_derived()?;
+            Ok(veh)
         }
     } else if let Some(veh_file_path) = fastsim_api.veh_file {
         if is_adopt || is_adopt_hd {
-            let vehstring = fs::read_to_string(veh_file_path).unwrap();
-            let (vehstring, pwr_out_perc, h2share) = json_rewrite(vehstring);
+            let veh_string = fs::read_to_string(veh_file_path)?;
+            let (veh_string, pwr_out_perc, h2share) = json_rewrite(veh_string)?;
             hd_h2_diesel_ice_h2share = h2share;
             fc_pwr_out_perc = pwr_out_perc;
-            RustVehicle::from_json_str(&vehstring)
+            let mut veh = RustVehicle::from_json(&veh_string)?;
+            veh.set_derived()?;
+            Ok(veh)
         } else {
             RustVehicle::from_file(&veh_file_path)
         }
     } else {
         Ok(RustVehicle::mock_vehicle())
-    }
-    .unwrap();
-
-    #[cfg(not(windows))]
-    macro_rules! path_separator {
-        () => {
-            "/"
-        };
-    }
-
-    #[cfg(windows)]
-    macro_rules! path_separator {
-        () => {
-            r#"\"#
-        };
-    }
+    }?;
 
     if is_adopt {
-        let sdl = get_label_fe(&veh, Some(false), Some(false)).unwrap();
+        let sdl = get_label_fe(&veh, Some(false), Some(false))?;
         let res = AdoptResults {
             adjCombMpgge: sdl.0.adj_comb_mpgge,
             rangeMiles: sdl.0.net_range_miles,
@@ -290,36 +280,17 @@ pub fn main() {
             traceMissInMph: sdl.0.trace_miss_speed_mph,
             h2AndDiesel: None,
         };
-        println!("{}", res.to_json());
+        println!("{}", res.to_json()?);
     } else if is_adopt_hd {
-        let hd_cyc_filestring = include_str!(concat!(
-            "..",
-            path_separator!(),
-            "..",
-            path_separator!(),
-            "..",
-            path_separator!(),
-            "..",
-            path_separator!(),
-            "python",
-            path_separator!(),
-            "fastsim",
-            path_separator!(),
-            "resources",
-            path_separator!(),
-            "cycles",
-            path_separator!(),
-            "HHDDTCruiseSmooth.csv"
-        ));
         let cyc = if adopt_hd_has_cycle {
             cyc
         } else {
-            RustCycle::from_csv_string(hd_cyc_filestring, "HHDDTCruiseSmooth".to_string()).unwrap()
+            RustCycle::from_resource("cycles/HHDDTCruiseSmooth.csv")?
         };
         let mut sim_drive = RustSimDrive::new(cyc, veh.clone());
-        sim_drive.sim_drive(None, None).unwrap();
+        sim_drive.sim_drive(None, None)?;
         let mut sim_drive_accel = RustSimDrive::new(make_accel_trace(), veh.clone());
-        let net_accel = get_net_accel(&mut sim_drive_accel, &veh.scenario_name).unwrap();
+        let net_accel = get_net_accel(&mut sim_drive_accel, &veh.scenario_name)?;
         let mut mpgge = sim_drive.mpgge;
 
         let h2_diesel_results = if let Some(hd_h2_diesel_ice_h2share) = hd_h2_diesel_ice_h2share {
@@ -333,7 +304,7 @@ pub fn main() {
                     &sim_drive.fs_kwh_out_ach.to_vec(),
                     &fc_pwr_out_perc,
                     &hd_h2_diesel_ice_h2share,
-                );
+                )?;
                 mpgge = dist_mi / (r.diesel_gge + r.h2_gge);
                 Some(r)
             } else {
@@ -358,16 +329,17 @@ pub fn main() {
             traceMissInMph: sim_drive.trace_miss_speed_mps * MPH_PER_MPS,
             h2AndDiesel: h2_diesel_results,
         };
-        println!("{}", res.to_json());
+        println!("{}", res.to_json()?);
     } else {
         let mut sim_drive = RustSimDrive::new(cyc, veh);
         // // this does nothing if it has already been called for the constructed `sim_drive`
-        sim_drive.sim_drive(None, None).unwrap();
+        sim_drive.sim_drive(None, None)?;
         println!("{}", sim_drive.mpgge);
     }
     // else {
     //     println!("Invalid option `{}` for `--res-fmt`", res_fmt);
     // }
+    Ok(())
 }
 
 fn translate_veh_pt_type(x: i64) -> String {
@@ -422,13 +394,14 @@ struct ParsedValue(Value);
 impl SerdeAPI for ParsedValue {}
 
 /// Rewrites the ADOPT JSON string to be in compliance with what FASTSim expects for JSON input.
-fn json_rewrite(x: String) -> (String, Option<Vec<f64>>, Option<Vec<f64>>) {
+#[allow(clippy::type_complexity)]
+fn json_rewrite(x: String) -> anyhow::Result<(String, Option<Vec<f64>>, Option<Vec<f64>>)> {
     let adoptstring = x;
 
     let mut fc_pwr_out_perc: Option<Vec<f64>> = None;
     let mut hd_h2_diesel_ice_h2share: Option<Vec<f64>> = None;
 
-    let mut parsed_data: Value = serde_json::from_str(&adoptstring).unwrap();
+    let mut parsed_data: Value = serde_json::from_str(&adoptstring)?;
 
     let veh_pt_type_raw = &parsed_data["vehPtType"];
     if veh_pt_type_raw.is_i64() {
@@ -520,7 +493,7 @@ fn json_rewrite(x: String) -> (String, Option<Vec<f64>>, Option<Vec<f64>>) {
 
     parsed_data["stop_start"] = json!(false);
 
-    let adoptstring = ParsedValue(parsed_data).to_json();
+    let adoptstring = ParsedValue(parsed_data).to_json()?;
 
-    (adoptstring, fc_pwr_out_perc, hd_h2_diesel_ice_h2share)
+    Ok((adoptstring, fc_pwr_out_perc, hd_h2_diesel_ice_h2share))
 }

rust/fastsim-cli/tests/integration-tests.rs

@@ -5,8 +5,8 @@ use assert_cmd::prelude::{CommandCargoExt, OutputAssertExt};
 use predicates::prelude::predicate;
 
 #[test]
-fn test_that_cli_app_produces_result() -> Result<(), Box<dyn std::error::Error>> {
-    let mut cmd = Command::cargo_bin("fastsim-cli")?;
+fn test_that_cli_app_produces_result() {
+    let mut cmd = Command::cargo_bin("fastsim-cli").unwrap();
     let mut cyc_file = project_root::get_project_root().unwrap();
     cyc_file.push(Path::new("../python/fastsim/resources/cycles/udds.csv"));
     cyc_file = cyc_file.canonicalize().unwrap();
@@ -28,17 +28,16 @@ fn test_that_cli_app_produces_result() -> Result<(), Box<dyn std::error::Error>>
     cmd.assert()
         .success()
         .stdout(predicate::str::contains("33.8"));
-    Ok(())
 }
 
 #[test]
-fn test_that_adopt_hd_option_works_as_expected() -> Result<(), Box<dyn std::error::Error>> {
+fn test_that_adopt_hd_option_works_as_expected() {
     let expected_results = vec![
         ("adoptstring.json", "0.245"),  // 0.245 kWh/mile
         ("adoptstring2.json", "7.906"), // 7.906 mpgge
         ("adoptstring3.json", "6.882"), // 6.882 mpgge
     ];
-    let mut cmd = Command::cargo_bin("fastsim-cli")?;
+    let mut cmd = Command::cargo_bin("fastsim-cli").unwrap();
     for (veh_file, expected_result) in expected_results.iter() {
         let mut adopt_veh_file = project_root::get_project_root().unwrap();
         let mut adopt_str_path = String::from("../rust/fastsim-cli/tests/assets/");
@@ -59,5 +58,4 @@ fn test_that_adopt_hd_option_works_as_expected() -> Result<(), Box<dyn std::erro
             .success()
             .stdout(predicate::str::contains(expected_mpg));
     }
-    Ok(())
 }

rust/fastsim-core/Cargo.toml

@@ -32,6 +32,7 @@ validator = { version = "0.16", features = ["derive"] }
 lazy_static = "1.4.0"
 regex = "1.7.1"
 rayon = "1.7.0"
+include_dir = "0.7.3"
 
 [package.metadata]
 include = [

rust/fastsim-core/build.rs

@@ -47,11 +47,11 @@ fn main() {
             env::current_dir().unwrap().as_os_str().to_str().unwrap()
         ),
         format!(
-            "{}/resources/udds.csv",
+            "{}/resources/cycles/udds.csv",
             env::current_dir().unwrap().as_os_str().to_str().unwrap()
         ),
         format!(
-            "{}/resources/hwfet.csv",
+            "{}/resources/cycles/hwfet.csv",
             env::current_dir().unwrap().as_os_str().to_str().unwrap()
         ),
     ];