Rename energy limits to activity limits

Author: alexdewar

src/asset.rs

@@ -85,13 +85,11 @@ impl Asset {
         self.commission_year + self.process_parameter.lifetime
     }
 
-    /// Get the energy limits for this asset in a particular time slice
-    ///
-    /// This is an absolute max and min on the energy produced/consumed in that time slice.
-    pub fn get_energy_limits(&self, time_slice: &TimeSliceID) -> RangeInclusive<f64> {
+    /// Get the activity limits for this asset in a particular time slice
+    pub fn get_activity_limits(&self, time_slice: &TimeSliceID) -> RangeInclusive<f64> {
         let limits = self
             .process
-            .energy_limits
+            .activity_limits
             .get(&(
                 self.region_id.clone(),
                 self.commission_year,
@@ -100,12 +98,11 @@ impl Asset {
             .unwrap();
         let max_act = self.maximum_activity();
 
-        // Multiply the fractional energy limits by this asset's maximum activity to get energy
         // limits in real units (which are user defined)
         (max_act * limits.start())..=(max_act * limits.end())
     }
 
-    /// Maximum activity for this asset (energy produced/consumed per year)
+    /// Maximum activity for this asset
     pub fn maximum_activity(&self) -> f64 {
         self.capacity * self.process_parameter.capacity_to_activity
     }
@@ -312,7 +309,7 @@ mod tests {
     use super::*;
     use crate::fixture::{assert_error, process};
     use crate::process::{
-        Process, ProcessEnergyLimitsMap, ProcessFlowsMap, ProcessParameter, ProcessParameterMap,
+        Process, ProcessActivityLimitsMap, ProcessFlowsMap, ProcessParameter, ProcessParameterMap,
     };
     use itertools::{assert_equal, Itertools};
     use rstest::{fixture, rstest};
@@ -387,7 +384,7 @@ mod tests {
             id: "process1".into(),
             description: "Description".into(),
             years: vec![2010, 2020],
-            energy_limits: ProcessEnergyLimitsMap::new(),
+            activity_limits: ProcessActivityLimitsMap::new(),
             flows: ProcessFlowsMap::new(),
             parameters: process_parameter_map,
             regions: HashSet::from(["GBR".into()]),
@@ -410,7 +407,7 @@ mod tests {
     }
 
     #[test]
-    fn test_asset_get_energy_limits() {
+    fn test_asset_get_activity_limits() {
         let time_slice = TimeSliceID {
             season: "winter".into(),
             time_of_day: "day".into(),
@@ -429,9 +426,9 @@ mod tests {
             .map(|&year| (("GBR".into(), year), process_param.clone()))
             .collect();
         let fraction_limits = 1.0..=f64::INFINITY;
-        let mut energy_limits = ProcessEnergyLimitsMap::new();
+        let mut activity_limits = ProcessActivityLimitsMap::new();
         for year in [2010, 2020] {
-            energy_limits.insert(
+            activity_limits.insert(
                 ("GBR".into(), year, time_slice.clone()),
                 fraction_limits.clone(),
             );
@@ -440,7 +437,7 @@ mod tests {
             id: "process1".into(),
             description: "Description".into(),
             years: vec![2010, 2020],
-            energy_limits,
+            activity_limits,
             flows: ProcessFlowsMap::new(),
             parameters: process_parameter_map,
             regions: HashSet::from(["GBR".into()]),
@@ -454,7 +451,7 @@ mod tests {
         )
         .unwrap();
 
-        assert_eq!(asset.get_energy_limits(&time_slice), 6.0..=f64::INFINITY);
+        assert_eq!(asset.get_activity_limits(&time_slice), 6.0..=f64::INFINITY);
     }
 
     #[rstest]

src/fixture.rs

@@ -7,7 +7,7 @@ use crate::agent::{
 use crate::asset::{Asset, AssetPool};
 use crate::commodity::{Commodity, CommodityID, CommodityLevyMap, CommodityType, DemandMap};
 use crate::process::{
-    Process, ProcessEnergyLimitsMap, ProcessFlowsMap, ProcessMap, ProcessParameter,
+    Process, ProcessActivityLimitsMap, ProcessFlowsMap, ProcessMap, ProcessParameter,
     ProcessParameterMap,
 };
 use crate::region::RegionID;
@@ -114,7 +114,7 @@ pub fn process(
         id: "process1".into(),
         description: "Description".into(),
         years: vec![2010, 2020],
-        energy_limits: ProcessEnergyLimitsMap::new(),
+        activity_limits: ProcessActivityLimitsMap::new(),
         flows: ProcessFlowsMap::new(),
         parameters: process_parameter_map,
         regions: region_ids,

src/input/agent/search_space.rs

@@ -157,7 +157,9 @@ where
 mod tests {
     use super::*;
     use crate::fixture::{agents, assert_error, region_ids};
-    use crate::process::{ProcessEnergyLimitsMap, ProcessFlowsMap, ProcessID, ProcessParameterMap};
+    use crate::process::{
+        ProcessActivityLimitsMap, ProcessFlowsMap, ProcessID, ProcessParameterMap,
+    };
     use crate::region::RegionID;
     use rstest::{fixture, rstest};
     use std::iter;
@@ -171,7 +173,7 @@ mod tests {
                     id: id.clone(),
                     description: "Description".into(),
                     years: vec![2010, 2020],
-                    energy_limits: ProcessEnergyLimitsMap::new(),
+                    activity_limits: ProcessActivityLimitsMap::new(),
                     flows: ProcessFlowsMap::new(),
                     parameters: ProcessParameterMap::new(),
                     regions: region_ids.clone(),

src/input/process.rs

@@ -2,7 +2,7 @@
 use super::*;
 use crate::commodity::{Commodity, CommodityID, CommodityMap, CommodityType};
 use crate::process::{
-    Process, ProcessEnergyLimitsMap, ProcessFlowsMap, ProcessID, ProcessMap, ProcessParameterMap,
+    Process, ProcessActivityLimitsMap, ProcessFlowsMap, ProcessID, ProcessMap, ProcessParameterMap,
 };
 use crate::region::{parse_region_str, RegionID};
 use crate::time_slice::{TimeSliceInfo, TimeSliceSelection};
@@ -55,7 +55,7 @@ pub fn read_processes(
     let mut processes = read_processes_file(model_dir, milestone_years, region_ids)?;
     let process_ids = processes.keys().cloned().collect();
 
-    let mut energy_limits =
+    let mut activity_limits =
         read_process_availabilities(model_dir, &process_ids, &processes, time_slice_info)?;
     let mut flows = read_process_flows(model_dir, &process_ids, &processes, commodities)?;
     let mut parameters = read_process_parameters(model_dir, &process_ids, &processes)?;
@@ -64,15 +64,15 @@ pub fn read_processes(
     validate_commodities(
         commodities,
         &flows,
-        &energy_limits,
+        &activity_limits,
         region_ids,
         milestone_years,
         time_slice_info,
     )?;
 
     // Add data to Process objects
     for (id, process) in processes.iter_mut() {
-        process.energy_limits = energy_limits
+        process.activity_limits = activity_limits
             .remove(id)
             .with_context(|| format!("Missing availabilities for process {id}"))?;
         process.flows = flows
@@ -139,7 +139,7 @@ where
             id: process_raw.id.clone(),
             description: process_raw.description,
             years,
-            energy_limits: ProcessEnergyLimitsMap::new(),
+            activity_limits: ProcessActivityLimitsMap::new(),
             flows: ProcessFlowsMap::new(),
             parameters: ProcessParameterMap::new(),
             regions,
@@ -158,7 +158,7 @@ where
 fn validate_commodities(
     commodities: &CommodityMap,
     flows: &HashMap<ProcessID, ProcessFlowsMap>,
-    availabilities: &HashMap<ProcessID, ProcessEnergyLimitsMap>,
+    availabilities: &HashMap<ProcessID, ProcessActivityLimitsMap>,
     region_ids: &HashSet<RegionID>,
     milestone_years: &[u32],
     time_slice_info: &TimeSliceInfo,
@@ -227,7 +227,7 @@ fn validate_svd_commodity(
     time_slice_info: &TimeSliceInfo,
     commodity: &Commodity,
     flows: &HashMap<ProcessID, ProcessFlowsMap>,
-    availabilities: &HashMap<ProcessID, ProcessEnergyLimitsMap>,
+    availabilities: &HashMap<ProcessID, ProcessActivityLimitsMap>,
     region_id: &RegionID,
     year: &u32,
     ts_selection: &TimeSliceSelection,
@@ -395,7 +395,7 @@ mod tests {
     ) {
         let availabilities = HashMap::from_iter(vec![(
             "process1".into(),
-            ProcessEnergyLimitsMap::from_iter(vec![(
+            ProcessActivityLimitsMap::from_iter(vec![(
                 ("GBR".into(), 2010, time_slice.clone()),
                 0.1..=0.9,
             )]),
@@ -424,7 +424,7 @@ mod tests {
         // Invalid scenario: no availability
         let availabilities = HashMap::from_iter(vec![(
             "process1".into(),
-            ProcessEnergyLimitsMap::from_iter(vec![(
+            ProcessActivityLimitsMap::from_iter(vec![(
                 ("GBR".into(), 2010, time_slice.clone()),
                 0.0..=0.0,
             )]),

src/input/process/availability.rs

@@ -1,7 +1,7 @@
 //! Code for reading process availabilities CSV file
 use super::super::*;
 use crate::id::IDCollection;
-use crate::process::{Process, ProcessEnergyLimitsMap, ProcessID};
+use crate::process::{Process, ProcessActivityLimitsMap, ProcessID};
 use crate::region::parse_region_str;
 use crate::time_slice::TimeSliceInfo;
 use crate::year::parse_year_str;
@@ -82,7 +82,7 @@ pub fn read_process_availabilities(
     process_ids: &IndexSet<ProcessID>,
     processes: &HashMap<ProcessID, Process>,
     time_slice_info: &TimeSliceInfo,
-) -> Result<HashMap<ProcessID, ProcessEnergyLimitsMap>> {
+) -> Result<HashMap<ProcessID, ProcessActivityLimitsMap>> {
     let file_path = model_dir.join(PROCESS_AVAILABILITIES_FILE_NAME);
     let process_availabilities_csv = read_csv(&file_path)?;
     read_process_availabilities_from_iter(
@@ -100,7 +100,7 @@ fn read_process_availabilities_from_iter<I>(
     process_ids: &IndexSet<ProcessID>,
     processes: &HashMap<ProcessID, Process>,
     time_slice_info: &TimeSliceInfo,
-) -> Result<HashMap<ProcessID, ProcessEnergyLimitsMap>>
+) -> Result<HashMap<ProcessID, ProcessActivityLimitsMap>>
 where
     I: Iterator<Item = ProcessAvailabilityRaw>,
 {
@@ -130,10 +130,10 @@ where
         // Get timeslices
         let ts_selection = time_slice_info.get_selection(&record.time_slice)?;
 
-        // Insert the energy limit into the map
+        // Insert the activity limit into the map
         let entry = map
             .entry(id.clone())
-            .or_insert_with(ProcessEnergyLimitsMap::new);
+            .or_insert_with(ProcessActivityLimitsMap::new);
         for (time_slice, ts_length) in ts_selection.iter(time_slice_info) {
             let bounds = record.to_bounds(ts_length);
 
@@ -149,14 +149,14 @@ where
         }
     }
 
-    validate_energy_limits_maps(&map, processes, time_slice_info)?;
+    validate_activity_limits_maps(&map, processes, time_slice_info)?;
 
     Ok(map)
 }
 
-/// Check that every energy limits covers every time slice, and all regions/years of the process
-fn validate_energy_limits_maps(
-    map: &HashMap<ProcessID, ProcessEnergyLimitsMap>,
+/// Check that the activity limits cover every time slice and all regions/years of the process
+fn validate_activity_limits_maps(
+    map: &HashMap<ProcessID, ProcessActivityLimitsMap>,
     processes: &HashMap<ProcessID, Process>,
     time_slice_info: &TimeSliceInfo,
 ) -> Result<()> {

src/process.rs

@@ -15,16 +15,11 @@ define_id_type! {ProcessID}
 /// A map of [`Process`]es, keyed by process ID
 pub type ProcessMap = IndexMap<ProcessID, Rc<Process>>;
 
-/// A map indicating relative energy limits for a [`Process`] throughout the year.
+/// A map indicating activity limits for a [`Process`] throughout the year.
 ///
-/// The value is calculated as availability multiplied by time slice length. Note that it is a
-/// **fraction** of energy for the year; to calculate **actual** energy limits for a given time
-/// slice you need to know the maximum activity (energy per year) for the specific instance of a
-/// [`Process`] in use.
-///
-/// The limits are given as ranges, depending on the user-specified limit type and value for
-/// availability.
-pub type ProcessEnergyLimitsMap = HashMap<(RegionID, u32, TimeSliceID), RangeInclusive<f64>>;
+/// The value is calculated as availability multiplied by time slice length. The limits are given as
+/// ranges, depending on the user-specified limit type and value for availability.
+pub type ProcessActivityLimitsMap = HashMap<(RegionID, u32, TimeSliceID), RangeInclusive<f64>>;
 
 /// A map of [`ProcessParameter`]s, keyed by region and year
 pub type ProcessParameterMap = HashMap<(RegionID, u32), Rc<ProcessParameter>>;
@@ -43,8 +38,8 @@ pub struct Process {
     pub description: String,
     /// The years in which this process is available for investment
     pub years: Vec<u32>,
-    /// Limits on energy consumption/production for each time slice (as a fraction of maximum)
-    pub energy_limits: ProcessEnergyLimitsMap,
+    /// Limits on activity for each time slice (as a fraction of maximum)
+    pub activity_limits: ProcessActivityLimitsMap,
     /// Maximum annual commodity flows for this process
     pub flows: ProcessFlowsMap,
     /// Additional parameters for this process