Merge remote-tracking branch 'origin/main' into prohibit-dubious-ids

Author: alexdewar

examples/simple/agents.csv

@@ -1,5 +1,5 @@
 id,description,regions,decision_rule,decision_lexico_tolerance
-A0_GEX,Gas extractors,GBR,single,
-A0_GPR,Gas processors,GBR,single,
-A0_ELC,Electricity generators,GBR,single,
-A0_RES,Residential consumer,GBR,single,
+A0_GEX,Gas extractors,all,single,
+A0_GPR,Gas processors,all,single,
+A0_ELC,Electricity generators,all,single,
+A0_RES,Residential consumer,all,single,

examples/simple/commodity_costs.csv

@@ -1,2 +1,2 @@
 commodity_id,regions,years,time_slice,balance_type,value
-CO2EMT,GBR,all,annual,net,0.04
+CO2EMT,all,all,annual,net,0.04

examples/simple/process_parameters.csv

@@ -1,7 +1,7 @@
 process_id,regions,years,capital_cost,fixed_operating_cost,variable_operating_cost,lifetime,discount_rate,capacity_to_activity
-GASDRV,GBR,all,10.0,0.3,2.0,25,0.1,1.0
-GASPRC,GBR,all,7.0,0.21,0.5,25,0.1,1.0
-WNDFRM,GBR,all,1000.0,30.0,0.4,25,0.1,31.54
-GASCGT,GBR,all,700.0,21.0,0.55,30,0.1,31.54
-RGASBR,GBR,all,55.56,1.6668,0.16,15,0.1,1.0
-RELCHP,GBR,all,138.9,4.167,0.17,15,0.1,1.0
+GASDRV,all,all,10.0,0.3,2.0,25,0.1,1.0
+GASPRC,all,all,7.0,0.21,0.5,25,0.1,1.0
+WNDFRM,all,all,1000.0,30.0,0.4,25,0.1,31.54
+GASCGT,all,all,700.0,21.0,0.55,30,0.1,31.54
+RGASBR,all,all,55.56,1.6668,0.16,15,0.1,1.0
+RELCHP,all,all,138.9,4.167,0.17,15,0.1,1.0

examples/simple/processes.csv

@@ -1,7 +1,7 @@
 id,description,regions,start_year,end_year
-GASDRV,Dry gas extraction,GBR,2020,2030
-GASPRC,Gas processing,GBR,2020,2030
-WNDFRM,Wind farm,GBR,2020,2030
-GASCGT,Gas combined cycle turbine,GBR,2020,2030
-RGASBR,Gas boiler,GBR,2020,2030
-RELCHP,Heat pump,GBR,2020,2030
+GASDRV,Dry gas extraction,all,2020,2030
+GASPRC,Gas processing,all,2020,2030
+WNDFRM,Wind farm,all,2020,2030
+GASCGT,Gas combined cycle turbine,all,2020,2030
+RGASBR,Gas boiler,all,2020,2030
+RELCHP,Heat pump,all,2020,2030

src/fixture.rs

@@ -4,12 +4,13 @@ use crate::agent::{
     Agent, AgentCommodityPortionsMap, AgentCostLimitsMap, AgentMap, AgentObjectiveMap,
     AgentSearchSpaceMap, DecisionRule,
 };
+use crate::commodity::CommodityID;
 use crate::process::{
     Process, ProcessEnergyLimitsMap, ProcessFlowsMap, ProcessMap, ProcessParameter,
     ProcessParameterMap,
 };
 use crate::region::RegionID;
-use crate::time_slice::TimeSliceID;
+use crate::time_slice::{TimeSliceID, TimeSliceInfo};
 use indexmap::indexmap;
 use itertools::Itertools;
 use rstest::fixture;
@@ -28,6 +29,11 @@ macro_rules! assert_error {
 }
 pub(crate) use assert_error;
 
+#[fixture]
+pub fn commodity_ids() -> HashSet<CommodityID> {
+    iter::once("commodity1".into()).collect()
+}
+
 #[fixture]
 pub fn region_ids() -> HashSet<RegionID> {
     ["GBR".into(), "USA".into()].into_iter().collect()
@@ -97,3 +103,20 @@ pub fn time_slice() -> TimeSliceID {
         time_of_day: "day".into(),
     }
 }
+
+#[fixture]
+pub fn time_slice_info() -> TimeSliceInfo {
+    TimeSliceInfo {
+        seasons: iter::once("winter".into()).collect(),
+        times_of_day: iter::once("day".into()).collect(),
+        fractions: [(
+            TimeSliceID {
+                season: "winter".into(),
+                time_of_day: "day".into(),
+            },
+            1.0,
+        )]
+        .into_iter()
+        .collect(),
+    }
+}

src/id.rs

@@ -1,17 +1,14 @@
 //! Code for handling IDs
 use anyhow::{Context, Result};
-use indexmap::IndexSet;
+use indexmap::{IndexMap, IndexSet};
+use std::borrow::Borrow;
 use std::collections::HashSet;
+use std::fmt::Display;
+use std::hash::Hash;
 
 /// A trait alias for ID types
-pub trait IDLike:
-    Eq + std::hash::Hash + std::borrow::Borrow<str> + Clone + std::fmt::Display + From<String>
-{
-}
-impl<T> IDLike for T where
-    T: Eq + std::hash::Hash + std::borrow::Borrow<str> + Clone + std::fmt::Display + From<String>
-{
-}
+pub trait IDLike: Eq + Hash + Borrow<str> + Clone + Display + From<String> {}
+impl<T> IDLike for T where T: Eq + Hash + Borrow<str> + Clone + Display + From<String> {}
 
 macro_rules! define_id_type {
     ($name:ident) => {
@@ -102,43 +99,25 @@ pub(crate) use define_id_getter;
 
 /// A data structure containing a set of IDs
 pub trait IDCollection<ID: IDLike> {
-    /// Get the ID from the collection by its string representation.
-    ///
-    /// # Arguments
-    ///
-    /// * `id` - The string representation of the ID
-    ///
-    /// # Returns
-    ///
-    /// A copy of the ID in `self`, or an error if not found.
-    fn get_id_by_str(&self, id: &str) -> Result<ID>;
-
     /// Check if the ID is in the collection, returning a copy of it if found.
     ///
     /// # Arguments
     ///
-    /// * `id` - The ID to check
+    /// * `id` - The ID to check (can be string or ID type)
     ///
     /// # Returns
     ///
     /// A copy of the ID in `self`, or an error if not found.
-    fn get_id(&self, id: &ID) -> Result<ID>;
+    fn get_id<T: Borrow<str> + Display + ?Sized>(&self, id: &T) -> Result<&ID>;
 }
 
 macro_rules! define_id_methods {
     () => {
-        fn get_id_by_str(&self, id: &str) -> Result<ID> {
-            let found = self
-                .get(id)
-                .with_context(|| format!("Unknown ID {id} found"))?;
-            Ok(found.clone())
-        }
-
-        fn get_id(&self, id: &ID) -> Result<ID> {
+        fn get_id<T: Borrow<str> + Display + ?Sized>(&self, id: &T) -> Result<&ID> {
             let found = self
                 .get(id.borrow())
                 .with_context(|| format!("Unknown ID {id} found"))?;
-            Ok(found.clone())
+            Ok(found)
         }
     };
 }
@@ -151,6 +130,15 @@ impl<ID: IDLike> IDCollection<ID> for IndexSet<ID> {
     define_id_methods!();
 }
 
+impl<ID: IDLike, V> IDCollection<ID> for IndexMap<ID, V> {
+    fn get_id<T: Borrow<str> + Display + ?Sized>(&self, id: &T) -> Result<&ID> {
+        let (found, _) = self
+            .get_key_value(id.borrow())
+            .with_context(|| format!("Unknown ID {id} found"))?;
+        Ok(found)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/input.rs

@@ -138,6 +138,15 @@ where
     Ok(())
 }
 
+/// Check whether an iterator contains values that are sorted and unique
+pub fn is_sorted_and_unique<T, I>(iter: I) -> bool
+where
+    T: PartialOrd + Clone,
+    I: IntoIterator<Item = T>,
+{
+    iter.into_iter().tuple_windows().all(|(a, b)| a < b)
+}
+
 /// Inserts a key-value pair into a HashMap if the key does not already exist.
 ///
 /// If the key already exists, it returns an error with a message indicating the key's existence.
@@ -200,9 +209,9 @@ pub fn load_model<P: AsRef<Path>>(model_dir: P) -> Result<(Model, AssetPool)> {
 
 #[cfg(test)]
 mod tests {
-    use crate::id::GenericID;
-
     use super::*;
+    use crate::id::GenericID;
+    use rstest::rstest;
     use serde::de::value::{Error as ValueError, F64Deserializer};
     use serde::de::IntoDeserializer;
     use serde::Deserialize;
@@ -324,4 +333,16 @@ mod tests {
         assert!(check_fractions_sum_to_one([f64::INFINITY].into_iter()).is_err());
         assert!(check_fractions_sum_to_one([f64::NAN].into_iter()).is_err());
     }
+
+    #[rstest]
+    #[case(&[], true)]
+    #[case(&[1], true)]
+    #[case(&[1,2], true)]
+    #[case(&[1,2,3,4], true)]
+    #[case(&[2,1],false)]
+    #[case(&[1,1],false)]
+    #[case(&[1,3,2,4], false)]
+    fn test_is_sorted_and_unique(#[case] values: &[u32], #[case] expected: bool) {
+        assert_eq!(is_sorted_and_unique(values), expected)
+    }
 }

src/input/agent/commodity_portion.rs

@@ -2,6 +2,7 @@
 use super::super::*;
 use crate::agent::{AgentCommodityPortionsMap, AgentID, AgentMap};
 use crate::commodity::{CommodityID, CommodityMap, CommodityType};
+use crate::id::IDCollection;
 use crate::region::RegionID;
 use crate::year::parse_year_str;
 use anyhow::{ensure, Context, Result};
@@ -66,9 +67,7 @@ where
     for agent_commodity_portion_raw in iter {
         // Get agent ID
         let agent_id_raw = agent_commodity_portion_raw.agent_id.as_str();
-        let (id, _agent) = agents
-            .get_key_value(agent_id_raw)
-            .with_context(|| format!("Invalid agent ID {agent_id_raw}"))?;
+        let id = agents.get_id(agent_id_raw)?;
 
         // Get/create entry for agent
         let entry = agent_commodity_portions
@@ -77,9 +76,7 @@ where
 
         // Insert portion for the commodity/year(s)
         let commodity_id_raw = agent_commodity_portion_raw.commodity_id.as_str();
-        let (commodity_id, _commodity) = commodities
-            .get_key_value(commodity_id_raw)
-            .with_context(|| format!("Invalid commodity ID {commodity_id_raw}"))?;
+        let commodity_id = commodities.get_id(commodity_id_raw)?;
         let years = parse_year_str(&agent_commodity_portion_raw.years, milestone_years)?;
         for year in years {
             try_insert(

src/input/agent/cost_limit.rs

@@ -61,7 +61,7 @@ where
         let years = parse_year_str(&agent_cost_limits_raw.years, milestone_years)?;
 
         // Get agent ID
-        let agent_id = agent_ids.get_id_by_str(&agent_cost_limits_raw.agent_id)?;
+        let agent_id = agent_ids.get_id(&agent_cost_limits_raw.agent_id)?;
 
         // Get or create entry in the map
         let entry = map.entry(agent_id.clone()).or_default();

src/input/agent/search_space.rs

@@ -52,18 +52,16 @@ impl AgentSearchSpaceRaw {
         let search_space = Rc::new(parse_search_space_str(&self.search_space, process_ids)?);
 
         // Get commodity
-        let commodity_id = commodity_ids.get_id_by_str(&self.commodity_id)?;
+        let commodity_id = commodity_ids.get_id(&self.commodity_id)?;
 
         // Check that the year is a valid milestone year
         let year = parse_year_str(&self.years, milestone_years)?;
 
-        let (agent_id, _) = agents
-            .get_key_value(self.agent_id.as_str())
-            .context("Invalid agent ID")?;
+        let agent_id = agents.get_id(&self.agent_id)?;
 
         Ok(AgentSearchSpace {
             agent_id: agent_id.clone(),
-            commodity_id,
+            commodity_id: commodity_id.clone(),
             years: year,
             search_space,
         })
@@ -86,7 +84,7 @@ fn parse_search_space_str(
     } else {
         search_space
             .split(';')
-            .map(|id| process_ids.get_id_by_str(id.trim()))
+            .map(|id| Ok(process_ids.get_id(id.trim())?.clone()))
             .try_collect()
     }
 }