Rename "capacity constraints" to "activity constraints" everywhere

Author: alexdewar

src/output.rs

@@ -32,8 +32,8 @@ const ASSETS_FILE_NAME: &str = "assets.csv";
 /// The output file name for commodity balance duals
 const COMMODITY_BALANCE_DUALS_FILE_NAME: &str = "debug_commodity_balance_duals.csv";
 
-/// The output file name for capacity duals
-const CAPACITY_DUALS_FILE_NAME: &str = "debug_capacity_duals.csv";
+/// The output file name for activity duals
+const ACTIVITY_DUALS_FILE_NAME: &str = "debug_activity_duals.csv";
 
 /// Get the model name from the specified directory path
 pub fn get_output_dir(model_dir: &Path) -> Result<PathBuf> {
@@ -111,9 +111,9 @@ struct CommodityPriceRow {
     price: f64,
 }
 
-/// Represents the capacity duals data in a row of the capacity duals CSV file
+/// Represents the activity duals data in a row of the activity duals CSV file
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
-struct CapacityDualsRow {
+struct ActivityDualsRow {
     milestone_year: u32,
     asset_id: AssetID,
     time_slice: TimeSliceID,
@@ -144,7 +144,7 @@ struct FixedAssetDualsRow {
 /// For writing extra debug information about the model
 struct DebugDataWriter {
     commodity_balance_duals_writer: csv::Writer<File>,
-    capacity_duals_writer: csv::Writer<File>,
+    activity_duals_writer: csv::Writer<File>,
 }
 
 impl DebugDataWriter {
@@ -161,33 +161,33 @@ impl DebugDataWriter {
 
         Ok(Self {
             commodity_balance_duals_writer: new_writer(COMMODITY_BALANCE_DUALS_FILE_NAME)?,
-            capacity_duals_writer: new_writer(CAPACITY_DUALS_FILE_NAME)?,
+            activity_duals_writer: new_writer(ACTIVITY_DUALS_FILE_NAME)?,
         })
     }
 
     /// Write all debug info to output files
     fn write_debug_info(&mut self, milestone_year: u32, solution: &Solution) -> Result<()> {
-        self.write_capacity_duals(milestone_year, solution.iter_capacity_duals())?;
+        self.write_activity_duals(milestone_year, solution.iter_activity_duals())?;
         self.write_commodity_balance_duals(
             milestone_year,
             solution.iter_commodity_balance_duals(),
         )?;
         Ok(())
     }
 
-    /// Write capacity duals to file
-    fn write_capacity_duals<'a, I>(&mut self, milestone_year: u32, iter: I) -> Result<()>
+    /// Write activity duals to file
+    fn write_activity_duals<'a, I>(&mut self, milestone_year: u32, iter: I) -> Result<()>
     where
         I: Iterator<Item = (&'a AssetRef, &'a TimeSliceID, f64)>,
     {
         for (asset, time_slice, value) in iter {
-            let row = CapacityDualsRow {
+            let row = ActivityDualsRow {
                 milestone_year,
                 asset_id: asset.id.unwrap(),
                 time_slice: time_slice.clone(),
                 value,
             };
-            self.capacity_duals_writer.serialize(row)?;
+            self.activity_duals_writer.serialize(row)?;
         }
 
         Ok(())
@@ -215,7 +215,7 @@ impl DebugDataWriter {
     /// Flush the underlying streams
     fn flush(&mut self) -> Result<()> {
         self.commodity_balance_duals_writer.flush()?;
-        self.capacity_duals_writer.flush()?;
+        self.activity_duals_writer.flush()?;
 
         Ok(())
     }
@@ -468,30 +468,30 @@ mod tests {
     }
 
     #[rstest]
-    fn test_write_capacity_duals(assets: AssetPool, time_slice: TimeSliceID) {
+    fn test_write_activity_duals(assets: AssetPool, time_slice: TimeSliceID) {
         let milestone_year = 2020;
         let value = 0.5;
         let dir = tempdir().unwrap();
         let asset = assets.iter().next().unwrap();
 
-        // Write capacity dual
+        // Write activity dual
         {
             let mut writer = DebugDataWriter::create(dir.path()).unwrap();
             writer
-                .write_capacity_duals(milestone_year, iter::once((asset, &time_slice, value)))
+                .write_activity_duals(milestone_year, iter::once((asset, &time_slice, value)))
                 .unwrap();
             writer.flush().unwrap();
         }
 
         // Read back and compare
-        let expected = CapacityDualsRow {
+        let expected = ActivityDualsRow {
             milestone_year,
             asset_id: asset.id.unwrap(),
             time_slice,
             value,
         };
-        let records: Vec<CapacityDualsRow> =
-            csv::Reader::from_path(dir.path().join(CAPACITY_DUALS_FILE_NAME))
+        let records: Vec<ActivityDualsRow> =
+            csv::Reader::from_path(dir.path().join(ACTIVITY_DUALS_FILE_NAME))
                 .unwrap()
                 .into_deserialize()
                 .try_collect()

src/simulation/optimisation.rs

@@ -94,10 +94,10 @@ impl Solution<'_> {
             })
     }
 
-    /// Keys and dual values for capacity constraints.
-    pub fn iter_capacity_duals(&self) -> impl Iterator<Item = (&AssetRef, &TimeSliceID, f64)> {
+    /// Keys and dual values for activity constraints.
+    pub fn iter_activity_duals(&self) -> impl Iterator<Item = (&AssetRef, &TimeSliceID, f64)> {
         self.constraint_keys
-            .capacity_keys
+            .activity_keys
             .zip_duals(self.solution.dual_rows())
             .map(|((asset, time_slice), dual)| (asset, time_slice, dual))
     }

src/simulation/optimisation/constraints.rs

@@ -28,34 +28,33 @@ impl<T> KeysWithOffset<T> {
 /// Indicates the commodity ID and time slice selection covered by each commodity balance constraint
 pub type CommodityBalanceKeys = KeysWithOffset<(CommodityID, RegionID, TimeSliceSelection)>;
 
-/// Indicates the asset ID and time slice covered by each capacity constraint
-pub type CapacityKeys = KeysWithOffset<(AssetRef, TimeSliceID)>;
+/// Indicates the asset ID and time slice covered by each activity constraint
+pub type ActivityKeys = KeysWithOffset<(AssetRef, TimeSliceID)>;
 
 /// The keys for different constraints
 pub struct ConstraintKeys {
     /// Keys for commodity balance constraints
     pub commodity_balance_keys: CommodityBalanceKeys,
-    /// Keys for capacity constraints
-    pub capacity_keys: CapacityKeys,
+    /// Keys for activity constraints
+    pub activity_keys: ActivityKeys,
 }
 
 /// Add asset-level constraints
 ///
 /// Note: the ordering of constraints is important, as the dual values of the constraints must later
 /// be retrieved to calculate commodity prices.
 ///
-/// # Arguments:
+/// # Arguments
 ///
 /// * `problem` - The optimisation problem
 /// * `variables` - The variables in the problem
 /// * `model` - The model
 /// * `assets` - The asset pool
 /// * `year` - Current milestone year
 ///
-/// # Returns:
+/// # Returns
 ///
-/// * A vector of keys for commodity balance constraints
-/// * A vector of keys for capacity constraints
+/// Keys for the different constraints.
 pub fn add_asset_constraints(
     problem: &mut Problem,
     variables: &VariableMap,
@@ -67,12 +66,12 @@ pub fn add_asset_constraints(
         add_commodity_balance_constraints(problem, variables, model, assets, year);
 
     let capacity_keys =
-        add_asset_capacity_constraints(problem, variables, &model.time_slice_info, assets);
+        add_activity_constraints(problem, variables, &model.time_slice_info, assets);
 
     // Return constraint keys
     ConstraintKeys {
         commodity_balance_keys,
-        capacity_keys,
+        activity_keys: capacity_keys,
     }
 }
 
@@ -101,16 +100,16 @@ fn add_commodity_balance_constraints(
     CommodityBalanceKeys { offset, keys }
 }
 
-/// Add asset-level capacity and availability constraints.
+/// Add constraints on the activity of different assets.
 ///
 /// This ensures that assets do not exceed their specified capacity and availability for each time
 /// slice.
-fn add_asset_capacity_constraints(
+fn add_activity_constraints(
     problem: &mut Problem,
     variables: &VariableMap,
     time_slice_info: &TimeSliceInfo,
     assets: &AssetPool,
-) -> CapacityKeys {
+) -> ActivityKeys {
     // Row offset in problem. This line **must** come before we add more constraints.
     let offset = problem.num_rows();
 
@@ -125,5 +124,5 @@ fn add_asset_capacity_constraints(
         }
     }
 
-    CapacityKeys { offset, keys }
+    ActivityKeys { offset, keys }
 }

src/simulation/prices.rs

@@ -39,7 +39,7 @@ impl CommodityPrices {
     /// Add commodity prices for which there are values in the solution
     ///
     /// Commodity prices are calculated as the sum of the commodity balance duals and the highest
-    /// capacity dual for each commodity/timeslice.
+    /// activity dual for each commodity/timeslice.
     ///
     /// # Arguments
     ///