Store agent objectives as a map

src/agent.rs

@@ -5,7 +5,6 @@ use crate::id::{define_id_getter, define_id_type};
 use crate::process::ProcessID;
 use crate::region::RegionID;
 use indexmap::IndexMap;
-use serde::Deserialize;
 use serde_string_enum::DeserializeLabeledStringEnum;
 use std::collections::HashMap;
 use std::collections::HashSet;
@@ -22,6 +21,12 @@ pub type AgentCostLimitsMap = HashMap<u32, AgentCostLimits>;
 /// A map of commodity portions for an agent, keyed by commodity and year
 pub type AgentCommodityPortionsMap = HashMap<(CommodityID, u32), f64>;
 
+/// A map of objectives for an agent, keyed by commodity and year.
+///
+/// NB: As we currently only support the "single" decision rule, the only parameter we need for
+/// objectives is the type.
+pub type AgentObjectiveMap = HashMap<u32, ObjectiveType>;
+
 /// An agent in the simulation
 #[derive(Debug, Clone, PartialEq)]
 pub struct Agent {
@@ -40,7 +45,7 @@ pub struct Agent {
     /// The regions in which this agent operates.
     pub regions: HashSet<RegionID>,
     /// The agent's objectives.
-    pub objectives: Vec<AgentObjective>,
+    pub objectives: AgentObjectiveMap,
 }
 define_id_getter! {Agent, AgentID}
 
@@ -78,23 +83,8 @@ pub enum DecisionRule {
     },
 }
 
-/// An objective for an agent with associated parameters
-#[derive(Debug, Clone, Deserialize, PartialEq)]
-pub struct AgentObjective {
-    /// Unique agent id identifying the agent this objective belongs to
-    pub agent_id: AgentID,
-    /// The year the objective is relevant for
-    pub year: u32,
-    /// Acronym identifying the objective (e.g. LCOX)
-    pub objective_type: ObjectiveType,
-    /// For the weighted sum decision rule, the set of weights to apply to each objective.
-    pub decision_weight: Option<f64>,
-    /// For the lexico decision rule, the order in which to consider objectives.
-    pub decision_lexico_order: Option<u32>,
-}
-
 /// The type of objective for the agent
-#[derive(Debug, Clone, PartialEq, DeserializeLabeledStringEnum)]
+#[derive(Debug, Clone, Copy, PartialEq, DeserializeLabeledStringEnum)]
 pub enum ObjectiveType {
     /// Average cost of one unit of output commodity over its lifetime
     #[string = "lcox"]

src/input/agent.rs

@@ -1,7 +1,8 @@
 //! Code for reading in agent-related data from CSV files.
 use super::*;
 use crate::agent::{
-    Agent, AgentCommodityPortionsMap, AgentCostLimitsMap, AgentID, AgentMap, DecisionRule,
+    Agent, AgentCommodityPortionsMap, AgentCostLimitsMap, AgentID, AgentMap, AgentObjectiveMap,
+    DecisionRule,
 };
 use crate::commodity::CommodityMap;
 use crate::process::ProcessMap;
@@ -138,6 +139,11 @@ where
             invalid_rule => bail!("Invalid decision rule: {}", invalid_rule),
         };
 
+        ensure!(
+            decision_rule == DecisionRule::Single,
+            "Currently only the \"single\" decision rule is supported"
+        );
+
         let agent = Agent {
             id: AgentID(agent_raw.id.into()),
             description: agent_raw.description,
@@ -146,7 +152,7 @@ where
             decision_rule,
             cost_limits: AgentCostLimitsMap::new(),
             regions,
-            objectives: Vec::new(),
+            objectives: AgentObjectiveMap::new(),
         };
 
         ensure!(
@@ -183,7 +189,7 @@ mod tests {
             decision_rule: DecisionRule::Single,
             cost_limits: AgentCostLimitsMap::new(),
             regions: HashSet::from(["GBR".into()]),
-            objectives: Vec::new(),
+            objectives: AgentObjectiveMap::new(),
         };
         let expected = AgentMap::from_iter(iter::once(("agent".into(), agent_out)));
         let actual = read_agents_file_from_iter(iter::once(agent), &region_ids).unwrap();

src/input/agent/commodity_portion.rs

@@ -194,7 +194,7 @@ fn validate_agent_commodity_portions(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::agent::{Agent, AgentCostLimitsMap, DecisionRule};
+    use crate::agent::{Agent, AgentCostLimitsMap, AgentObjectiveMap, DecisionRule};
     use crate::commodity::{Commodity, CommodityCostMap, CommodityID, CommodityType, DemandMap};
     use crate::time_slice::TimeSliceLevel;
     use std::rc::Rc;
@@ -213,7 +213,7 @@ mod tests {
                 decision_rule: DecisionRule::Single,
                 cost_limits: AgentCostLimitsMap::new(),
                 regions: region_ids.clone(),
-                objectives: Vec::new(),
+                objectives: AgentObjectiveMap::new(),
             },
         )]);
         let mut commodities = IndexMap::from([(