Merge remote-tracking branch 'origin/main' into other-commodities

alexdewar · alexdewar · commit e7d35e7576f7 · 2025-06-17T16:35:57.000+01:00
diff --git a/src/asset.rs b/src/asset.rs
@@ -264,20 +264,15 @@ impl AssetPool {
         self.iter().filter(|asset| asset.region_id == *region_id)
     }
 
-    /// Iterate over only the active assets in a given region that produce or consume a given
-    /// commodity
+    /// Iterate over the active assets in a given region that produce/consume a commodity with the
+    /// associated process flow
     pub fn iter_for_region_and_commodity<'a>(
         &'a self,
         region_id: &'a RegionID,
         commodity_id: &'a CommodityID,
-    ) -> impl Iterator<Item = &'a AssetRef> {
-        self.iter_for_region(region_id).filter(|asset| {
-            asset.process.contains_commodity_flow(
-                commodity_id,
-                &asset.region_id,
-                asset.commission_year,
-            )
-        })
+    ) -> impl Iterator<Item = (&'a AssetRef, &'a ProcessFlow)> {
+        self.iter_for_region(region_id)
+            .filter_map(|asset| Some((asset, asset.get_flow(commodity_id)?)))
     }
 
     /// Replace the active pool with new and/or already commissioned assets
diff --git a/src/input/commodity/demand.rs b/src/input/commodity/demand.rs
@@ -187,7 +187,7 @@ fn compute_demand_maps(
 ) -> HashMap<CommodityID, DemandMap> {
     let mut map = HashMap::new();
     for ((commodity_id, region_id, year), (level, annual_demand)) in demand.iter() {
-        for ts_selection in time_slice_info.iter_selections_for_level(*level) {
+        for ts_selection in time_slice_info.iter_selections_at_level(*level) {
             let slice_key = (
                 commodity_id.clone(),
                 region_id.clone(),
diff --git a/src/input/commodity/demand_slicing.rs b/src/input/commodity/demand_slicing.rs
@@ -128,7 +128,7 @@ fn validate_demand_slices(
 ) -> Result<()> {
     for (commodity, region_id) in iproduct!(svd_commodities.values(), region_ids) {
         time_slice_info
-            .iter_selections_for_level(commodity.time_slice_level)
+            .iter_selections_at_level(commodity.time_slice_level)
             .map(|ts_selection| {
                 demand_slices
                     .get(&(
diff --git a/src/input/process.rs b/src/input/process.rs
@@ -170,7 +170,7 @@ fn validate_commodities(
                 }
                 CommodityType::ServiceDemand => {
                     for ts_selection in
-                        time_slice_info.iter_selections_for_level(commodity.time_slice_level)
+                        time_slice_info.iter_selections_at_level(commodity.time_slice_level)
                     {
                         validate_svd_commodity(
                             time_slice_info,
diff --git a/src/output.rs b/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,
@@ -130,21 +130,10 @@ struct CommodityBalanceDualsRow {
     value: f64,
 }
 
-/// Represents the fixed asset duals data in a row of the fixed asset duals CSV file
-#[derive(Serialize, Deserialize, Debug, PartialEq)]
-struct FixedAssetDualsRow {
-    pac: CommodityID,
-    pac_flow: f64,
-    commodity_id: CommodityID,
-    commodity_flow: f64,
-    time_slice: TimeSliceID,
-    value: f64,
-}
-
 /// 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 +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(())
@@ -215,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(())
     }
@@ -468,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()
diff --git a/src/process.rs b/src/process.rs
@@ -48,21 +48,6 @@ pub struct Process {
     pub regions: HashSet<RegionID>,
 }
 
-impl Process {
-    /// Whether the process contains a flow for a given commodity
-    pub fn contains_commodity_flow(
-        &self,
-        commodity_id: &CommodityID,
-        region_id: &RegionID,
-        year: u32,
-    ) -> bool {
-        self.flows
-            .get(&(region_id.clone(), year))
-            .unwrap() // all regions and years are covered
-            .contains_key(commodity_id)
-    }
-}
-
 /// Represents a maximum annual commodity coeff for a given process
 #[derive(PartialEq, Debug, Clone)]
 pub struct ProcessFlow {
diff --git a/src/simulation/optimisation.rs b/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))
     }
diff --git a/src/simulation/optimisation/constraints.rs b/src/simulation/optimisation/constraints.rs
@@ -1,7 +1,7 @@
 //! Code for adding constraints to the dispatch optimisation problem.
 use super::VariableMap;
 use crate::asset::{AssetPool, AssetRef};
-use crate::commodity::CommodityID;
+use crate::commodity::{CommodityID, CommodityType};
 use crate::model::Model;
 use crate::region::RegionID;
 use crate::time_slice::{TimeSliceID, TimeSliceInfo, TimeSliceSelection};
@@ -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,
     }
 }
 
@@ -85,44 +84,84 @@ pub fn add_asset_constraints(
 /// [1]: https://energysystemsmodellinglab.github.io/MUSE_2.0/dispatch_optimisation.html#commodity-balance-constraints
 fn add_commodity_balance_constraints(
     problem: &mut Problem,
-    _variables: &VariableMap,
-    _model: &Model,
-    _assets: &AssetPool,
-    _year: u32,
+    variables: &VariableMap,
+    model: &Model,
+    assets: &AssetPool,
+    year: u32,
 ) -> CommodityBalanceKeys {
     // Row offset in problem. This line **must** come before we add more constraints.
     let offset = problem.num_rows();
 
-    let keys = Vec::new();
-
-    // **TODO:** Add commodity balance constraints:
-    //  https://github.com/EnergySystemsModellingLab/MUSE_2.0/issues/577
+    let mut keys = Vec::new();
+    let mut terms = Vec::new();
+    for (commodity_id, commodity) in model.commodities.iter() {
+        if !matches!(
+            commodity.kind,
+            CommodityType::SupplyEqualsDemand | CommodityType::ServiceDemand
+        ) {
+            continue;
+        }
+
+        for region_id in model.iter_regions() {
+            for ts_selection in model
+                .time_slice_info
+                .iter_selections_at_level(commodity.time_slice_level)
+            {
+                for (asset, flow) in assets.iter_for_region_and_commodity(region_id, commodity_id) {
+                    // If the commodity has a time slice level of season/annual, the constraint will
+                    // cover multiple time slices
+                    for (time_slice, _) in ts_selection.iter(&model.time_slice_info) {
+                        let var = variables.get(asset, time_slice);
+                        terms.push((var, flow.coeff));
+                    }
+                }
+
+                // Add constraint. For SED commodities, the RHS is zero and for SVD commodities it
+                // is the exogenous demand supplied by the user.
+                let rhs = if commodity.kind == CommodityType::ServiceDemand {
+                    *commodity
+                        .demand
+                        .get(&(region_id.clone(), year, ts_selection.clone()))
+                        .unwrap()
+                } else {
+                    0.0
+                };
+                problem.add_row(rhs..=rhs, terms.drain(..));
+                keys.push((
+                    commodity_id.clone(),
+                    region_id.clone(),
+                    ts_selection.clone(),
+                ))
+            }
+        }
+    }
 
     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 }
 }
diff --git a/src/simulation/prices.rs b/src/simulation/prices.rs
diff --git a/src/time_slice.rs b/src/time_slice.rs

Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ fn validate_commodities(`
`170`	`170`	`}`
`171`	`171`	`CommodityType::ServiceDemand => {`
`172`	`172`	`for ts_selection in`
`173`		`- time_slice_info.iter_selections_for_level(commodity.time_slice_level)`
	`173`	`+ time_slice_info.iter_selections_at_level(commodity.time_slice_level)`
`174`	`174`	`{`
`175`	`175`	`validate_svd_commodity(`
`176`	`176`	`time_slice_info,`
Original file line number	Diff line number	Diff line change
`@@ -94,10 +94,10 @@ impl Solution<'_> {`
`94`	`94`	`})`
`95`	`95`	`}`
`96`	`96`
`97`		`- /// Keys and dual values for capacity constraints.`
`98`		`- pub fn iter_capacity_duals(&self) -> impl Iterator<Item = (&AssetRef, &TimeSliceID, f64)> {`
	`97`	`+ /// Keys and dual values for activity constraints.`
	`98`	`+ pub fn iter_activity_duals(&self) -> impl Iterator<Item = (&AssetRef, &TimeSliceID, f64)> {`
`99`	`99`	`self.constraint_keys`
`100`		`- .capacity_keys`
	`100`	`+ .activity_keys`
`101`	`101`	`.zip_duals(self.solution.dual_rows())`
`102`	`102`	`.map(\|((asset, time_slice), dual)\| (asset, time_slice, dual))`
`103`	`103`	`}`