Merge branch 'main' into rc-assets

Author: alexdewar

examples/simple/process_availabilities.csv

@@ -1,9 +1,9 @@
 process_id,regions,years,time_slice,limit_type,value
-GASDRV,all,all,,up,0.9
-GASPRC,all,all,,up,0.9
-GASCGT,all,all,,up,0.9
-RGASBR,all,all,,up,1.0
-RELCHP,all,all,,up,1.0
+GASDRV,all,all,annual,up,0.9
+GASPRC,all,all,annual,up,0.9
+GASCGT,all,all,annual,up,0.9
+RGASBR,all,all,annual,up,1.0
+RELCHP,all,all,annual,up,1.0
 WNDFRM,all,all,winter.night,up,0.486418015
 WNDFRM,all,all,winter.day,up,0.543166784
 WNDFRM,all,all,winter.peak,up,0.504433498

src/commands.rs

@@ -3,7 +3,7 @@ use crate::input::load_model;
 use crate::log;
 use crate::output::{create_output_directory, get_output_dir};
 use crate::settings::Settings;
-use ::log::{error, info};
+use ::log::info;
 use anyhow::{ensure, Context, Result};
 use clap::{Parser, Subcommand};
 use include_dir::{include_dir, Dir, DirEntry};
@@ -98,20 +98,13 @@ pub fn handle_run_command(
     log::init(settings.log_level.as_deref(), &output_path)
         .context("Failed to initialise logging.")?;
 
-    let load_and_run_model = || {
-        // Load the model to run
-        let (model, assets) = load_model(model_path).context("Failed to load model.")?;
-        info!("Loaded model from {}", model_path.display());
-        info!("Output data will be written to {}", output_path.display());
+    // Load the model to run
+    let (model, assets) = load_model(model_path).context("Failed to load model.")?;
+    info!("Loaded model from {}", model_path.display());
+    info!("Output data will be written to {}", output_path.display());
 
-        // Run the simulation
-        crate::simulation::run(model, assets, &output_path, settings.debug_model)
-    };
-
-    // Once the logger is initialised, we can write fatal errors to log
-    if let Err(err) = load_and_run_model() {
-        error!("{err:?}");
-    }
+    // Run the simulation
+    crate::simulation::run(model, assets, &output_path, settings.debug_model)?;
 
     Ok(())
 }

src/commodity.rs

@@ -1,7 +1,7 @@
 //! Commodities are substances or forms of energy that can be produced and consumed by processes.
 use crate::id::{define_id_getter, define_id_type};
 use crate::region::RegionID;
-use crate::time_slice::{TimeSliceID, TimeSliceLevel};
+use crate::time_slice::{TimeSliceID, TimeSliceLevel, TimeSliceSelection};
 use indexmap::IndexMap;
 use serde::Deserialize;
 use serde_string_enum::DeserializeLabeledStringEnum;
@@ -16,8 +16,8 @@ pub type CommodityMap = IndexMap<CommodityID, Rc<Commodity>>;
 /// A map of [`CommodityCost`]s, keyed by region ID, year and time slice ID
 pub type CommodityCostMap = HashMap<(RegionID, u32, TimeSliceID), CommodityCost>;
 
-/// A map of demand values, keyed by region ID, year and time slice ID
-pub type DemandMap = HashMap<(RegionID, u32, TimeSliceID), f64>;
+/// A map of demand values, keyed by region ID, year and time slice selection
+pub type DemandMap = HashMap<(RegionID, u32, TimeSliceSelection), f64>;
 
 /// A commodity within the simulation.
 ///
@@ -42,6 +42,10 @@ pub struct Commodity {
     #[serde(skip)]
     pub costs: CommodityCostMap,
     /// Demand as defined in input files. Will be empty for non-service-demand commodities.
+    ///
+    /// The [`TimeSliceSelection`] part of the key is always at the same [`TimeSliceLevel`] as the
+    /// `time_slice_level` field. E.g. if the `time_slice_level` is seasonal, then there will be
+    /// keys representing each season (and not e.g. individual time slices).
     #[serde(skip)]
     pub demand: DemandMap,
 }
@@ -92,19 +96,20 @@ pub enum CommodityType {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::time_slice::TimeSliceSelection;
 
     #[test]
     fn test_demand_map() {
-        let time_slice = TimeSliceID {
+        let ts_selection = TimeSliceSelection::Single(TimeSliceID {
             season: "all-year".into(),
             time_of_day: "all-day".into(),
-        };
+        });
         let value = 0.25;
         let mut map = DemandMap::new();
-        map.insert(("North".into(), 2020, time_slice.clone()), value);
+        map.insert(("North".into(), 2020, ts_selection.clone()), value);
 
         assert_eq!(
-            map.get(&("North".into(), 2020, time_slice)).unwrap(),
+            map.get(&("North".into(), 2020, ts_selection)).unwrap(),
             &value
         )
     }

src/fixture.rs

@@ -5,17 +5,17 @@ use crate::agent::{
     AgentSearchSpaceMap, DecisionRule,
 };
 use crate::asset::{Asset, AssetPool};
-use crate::commodity::CommodityID;
+use crate::commodity::{Commodity, CommodityCostMap, CommodityID, CommodityType, DemandMap};
 use crate::process::{
     Process, ProcessEnergyLimitsMap, ProcessFlowsMap, ProcessMap, ProcessParameter,
     ProcessParameterMap,
 };
 use crate::region::RegionID;
-use crate::time_slice::{TimeSliceID, TimeSliceInfo};
+use crate::time_slice::{TimeSliceID, TimeSliceInfo, TimeSliceLevel};
 use indexmap::indexmap;
 use itertools::Itertools;
 use rstest::fixture;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::iter;
 use std::rc::Rc;
 
@@ -55,6 +55,22 @@ pub fn commodity_id() -> CommodityID {
     "commodity1".into()
 }
 
+#[fixture]
+pub fn svd_commodity() -> Commodity {
+    Commodity {
+        id: "commodity1".into(),
+        description: "".into(),
+        kind: CommodityType::ServiceDemand,
+        time_slice_level: TimeSliceLevel::DayNight,
+        costs: CommodityCostMap::new(),
+        demand: DemandMap::new(),
+    }
+}
+
+pub fn get_svd_map(commodity: &Commodity) -> HashMap<CommodityID, &Commodity> {
+    iter::once((commodity.id.clone(), commodity)).collect()
+}
+
 #[fixture]
 pub fn asset(process: Process) -> Asset {
     let region_id: RegionID = "GBR".into();
@@ -139,9 +155,9 @@ pub fn time_slice() -> TimeSliceID {
 #[fixture]
 pub fn time_slice_info() -> TimeSliceInfo {
     TimeSliceInfo {
-        seasons: iter::once("winter".into()).collect(),
         times_of_day: iter::once("day".into()).collect(),
-        fractions: [(
+        seasons: iter::once(("winter".into(), 1.0)).collect(),
+        time_slices: [(
             TimeSliceID {
                 season: "winter".into(),
                 time_of_day: "day".into(),

src/id.rs

@@ -12,7 +12,9 @@ impl<T> IDLike for T where T: Eq + Hash + Borrow<str> + Clone + Display + From<S
 
 macro_rules! define_id_type {
     ($name:ident) => {
-        #[derive(Clone, std::hash::Hash, PartialEq, Eq, Debug, serde::Serialize)]
+        #[derive(
+            Clone, std::hash::Hash, PartialOrd, Ord, PartialEq, Eq, Debug, serde::Serialize,
+        )]
         /// An ID type (e.g. `AgentID`, `CommodityID`, etc.)
         pub struct $name(pub std::rc::Rc<str>);
 

src/input/commodity/cost.rs

@@ -101,7 +101,7 @@ where
                 .or_default()
                 .insert(region.clone());
             for year in years.iter() {
-                for (time_slice, _) in time_slice_info.iter_selection(&ts_selection) {
+                for (time_slice, _) in ts_selection.iter(time_slice_info) {
                     try_insert(
                         map,
                         (region.clone(), *year, time_slice.clone()),
@@ -146,51 +146,86 @@ fn validate_commodity_cost_map(
 
 #[cfg(test)]
 mod tests {
+    use std::iter;
+
     use super::*;
+    use crate::fixture::{assert_error, region_id, time_slice, time_slice_info};
     use crate::time_slice::TimeSliceID;
+    use rstest::{fixture, rstest};
 
-    #[test]
-    fn test_validate_commodity_costs_map() {
-        // Set up time slices
-        let slice = TimeSliceID {
-            season: "winter".into(),
-            time_of_day: "day".into(),
-        };
-        let ts_info = TimeSliceInfo {
-            seasons: ["winter".into()].into(),
-            times_of_day: ["day".into()].into(),
-            fractions: [(slice.clone(), 1.0)].into(),
-        };
+    #[fixture]
+    fn region_ids(region_id: RegionID) -> HashSet<RegionID> {
+        iter::once(region_id).collect()
+    }
 
-        let regions = HashSet::from(["UK".into()]);
-        let milestone_years = [2020];
+    #[fixture]
+    fn cost_map(time_slice: TimeSliceID) -> CommodityCostMap {
         let cost = CommodityCost {
             balance_type: BalanceType::Net,
             value: 1.0,
         };
 
-        // Valid map
         let mut map = CommodityCostMap::new();
-        map.insert(("UK".into(), 2020, slice.clone()), cost.clone());
-        assert!(validate_commodity_cost_map(&map, &regions, &milestone_years, &ts_info).is_ok());
+        map.insert(("GBR".into(), 2020, time_slice.clone()), cost.clone());
+        map
+    }
+
+    #[rstest]
+    fn test_validate_commodity_costs_map_valid(
+        cost_map: CommodityCostMap,
+        time_slice_info: TimeSliceInfo,
+        region_ids: HashSet<RegionID>,
+    ) {
+        // Valid map
+        assert!(
+            validate_commodity_cost_map(&cost_map, &region_ids, &[2020], &time_slice_info).is_ok()
+        );
+    }
 
+    #[rstest]
+    fn test_validate_commodity_costs_map_invalid_missing_region(
+        cost_map: CommodityCostMap,
+        time_slice_info: TimeSliceInfo,
+    ) {
         // Missing region
-        let regions2 = HashSet::from(["UK".into(), "FR".into()]);
-        assert!(validate_commodity_cost_map(&map, &regions2, &milestone_years, &ts_info).is_err());
+        let region_ids = HashSet::from(["GBR".into(), "FRA".into()]);
+        assert_error!(
+            validate_commodity_cost_map(&cost_map, &region_ids, &[2020], &time_slice_info),
+            "Missing cost for region FRA, year 2020, time slice winter.day"
+        );
+    }
 
+    #[rstest]
+    fn test_validate_commodity_costs_map_invalid_missing_year(
+        cost_map: CommodityCostMap,
+        time_slice_info: TimeSliceInfo,
+        region_ids: HashSet<RegionID>,
+    ) {
         // Missing year
-        assert!(validate_commodity_cost_map(&map, &regions, &[2020, 2030], &ts_info).is_err());
+        assert_error!(
+            validate_commodity_cost_map(&cost_map, &region_ids, &[2020, 2030], &time_slice_info),
+            "Missing cost for region GBR, year 2030, time slice winter.day"
+        );
+    }
 
+    #[rstest]
+    fn test_validate_commodity_costs_map_invalid(
+        cost_map: CommodityCostMap,
+        region_ids: HashSet<RegionID>,
+    ) {
         // Missing time slice
-        let slice2 = TimeSliceID {
+        let time_slice = TimeSliceID {
             season: "winter".into(),
             time_of_day: "night".into(),
         };
-        let ts_info2 = TimeSliceInfo {
-            seasons: ["winter".into()].into(),
+        let time_slice_info = TimeSliceInfo {
+            seasons: [("winter".into(), 1.0)].into(),
             times_of_day: ["day".into(), "night".into()].into(),
-            fractions: [(slice.clone(), 0.5), (slice2.clone(), 0.5)].into(),
+            time_slices: [(time_slice.clone(), 0.5), (time_slice.clone(), 0.5)].into(),
         };
-        assert!(validate_commodity_cost_map(&map, &regions, &milestone_years, &ts_info2).is_err());
+        assert_error!(
+            validate_commodity_cost_map(&cost_map, &region_ids, &[2020], &time_slice_info),
+            "Missing cost for region GBR, year 2020, time slice winter.night"
+        );
     }
 }