Merge pull request #626 from EnergySystemsModellingLab/add-capacity-constraints

Add capacity constraints

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,
@@ -133,7 +133,7 @@ struct CommodityBalanceDualsRow {
 /// 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 {
@@ -150,33 +150,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(())
@@ -204,7 +204,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(())
     }
@@ -457,30 +457,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, assets, &model.time_slice_info);
+        add_activity_constraints(problem, variables, &model.time_slice_info, assets);
 
     // Return constraint keys
     ConstraintKeys {
         commodity_balance_keys,
-        capacity_keys,
+        activity_keys: capacity_keys,
     }
 }
 
@@ -140,28 +139,29 @@ fn add_commodity_balance_constraints(
     CommodityBalanceKeys { offset, keys }
 }
 
-/// Add asset-level capacity and availability constraints.
+/// Add constraints on the activity of different assets.
 ///
-/// For every asset at every time slice, the sum of the commodity flows for assets must not exceed
-/// the capacity limits, which are a product of the annual capacity, time slice length and process
-/// availability.
-///
-/// See description in [the dispatch optimisation documentation][1].
-///
-/// [1]: https://energysystemsmodellinglab.github.io/MUSE_2.0/dispatch_optimisation.html#asset-level-capacity-and-availability-constraints
-fn add_asset_capacity_constraints(
+/// This ensures that assets do not exceed their specified capacity and availability for each time
+/// slice.
+fn add_activity_constraints(
     problem: &mut Problem,
-    _variables: &VariableMap,
-    _assets: &AssetPool,
-    _time_slice_info: &TimeSliceInfo,
-) -> CapacityKeys {
+    variables: &VariableMap,
+    time_slice_info: &TimeSliceInfo,
+    assets: &AssetPool,
+) -> ActivityKeys {
     // Row offset in problem. This line **must** come before we add more constraints.
     let offset = problem.num_rows();
 
-    let keys = Vec::new();
+    let mut keys = Vec::new();
+    for asset in assets.iter() {
+        for time_slice in time_slice_info.iter_ids() {
+            let var = variables.get(asset, time_slice);
+            let limits = asset.get_activity_limits(time_slice);
 
-    // **TODO:** Add capacity/availability constraints:
-    //  https://github.com/EnergySystemsModellingLab/MUSE_2.0/issues/579
+            problem.add_row(limits, [(var, 1.0)]);
+            keys.push((asset.clone(), time_slice.clone()))
+        }
+    }
 
-    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
     ///