AssetPool: Represent assets with AssetRefs

Author: alexdewar

src/asset.rs

@@ -143,7 +143,7 @@ impl Asset {
 ///
 /// An [`AssetRef`] is guaranteed to have been commissioned at some point, though it may
 /// subsequently have been decommissioned.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct AssetRef(Rc<Asset>);
 
 impl From<Rc<Asset>> for AssetRef {
@@ -199,7 +199,7 @@ impl Hash for AssetRef {
 /// A pool of [`Asset`]s
 pub struct AssetPool {
     /// The pool of active assets
-    active: Vec<Rc<Asset>>,
+    active: Vec<AssetRef>,
     /// Assets that have not yet been commissioned, sorted by commission year
     future: Vec<Asset>,
     /// Next available asset ID number
@@ -245,9 +245,9 @@ impl AssetPool {
     ///
     /// # Returns
     ///
-    /// Reference to an [`Asset`] if found, else `None`. The asset may not be found if it has
-    /// already been decommissioned.
-    pub fn get(&self, id: AssetID) -> Option<&Rc<Asset>> {
+    /// An [`AssetRef`] if found, else `None`. The asset may not be found if it has already been
+    /// decommissioned.
+    pub fn get(&self, id: AssetID) -> Option<&AssetRef> {
         // The assets in `active` are in order of ID
         let idx = self
             .active
@@ -258,15 +258,15 @@ impl AssetPool {
     }
 
     /// Iterate over active assets
-    pub fn iter(&self) -> impl Iterator<Item = &Rc<Asset>> {
+    pub fn iter(&self) -> impl Iterator<Item = &AssetRef> {
         self.active.iter()
     }
 
     /// Iterate over active assets for a particular region
     pub fn iter_for_region<'a>(
         &'a self,
         region_id: &'a RegionID,
-    ) -> impl Iterator<Item = &'a Rc<Asset>> {
+    ) -> impl Iterator<Item = &'a AssetRef> {
         self.iter().filter(|asset| asset.region_id == *region_id)
     }
 
@@ -276,7 +276,7 @@ impl AssetPool {
         &'a self,
         region_id: &'a RegionID,
         commodity_id: &'a CommodityID,
-    ) -> impl Iterator<Item = &'a Rc<Asset>> {
+    ) -> impl Iterator<Item = &'a AssetRef> {
         self.iter_for_region(region_id).filter(|asset| {
             asset.process.contains_commodity_flow(
                 commodity_id,
@@ -294,7 +294,7 @@ impl AssetPool {
         let new_pool = assets.into_iter().map(|asset| {
             if asset.id != AssetID::INVALID {
                 // Already commissioned
-                asset
+                asset.into()
             } else {
                 // Newly created from process. We need to assign an ID.
                 let mut asset = asset.as_ref().clone();
@@ -514,7 +514,7 @@ mod tests {
     fn test_asset_pool_replace_active_pool_existing(mut asset_pool: AssetPool) {
         asset_pool.commission_new(2020);
         assert_eq!(asset_pool.active.len(), 2);
-        asset_pool.replace_active_pool(iter::once(asset_pool.active[1].clone()));
+        asset_pool.replace_active_pool(iter::once(asset_pool.active[1].clone().into()));
         assert_eq!(asset_pool.active.len(), 1);
         assert_eq!(asset_pool.active[0].id, AssetID(1));
     }

src/output.rs

@@ -13,7 +13,6 @@ use serde::{Deserialize, Serialize};
 use std::fs;
 use std::fs::File;
 use std::path::{Path, PathBuf};
-use std::rc::Rc;
 
 /// The root folder in which model-specific output folders will be created
 const OUTPUT_DIRECTORY_ROOT: &str = "muse2_results";
@@ -259,7 +258,7 @@ impl DataWriter {
     /// Write assets to a CSV file
     pub fn write_assets<'a, I>(&mut self, milestone_year: u32, assets: I) -> Result<()>
     where
-        I: Iterator<Item = &'a Rc<Asset>>,
+        I: Iterator<Item = &'a AssetRef>,
     {
         for asset in assets {
             let row = AssetRow::new(milestone_year, asset);
@@ -329,30 +328,28 @@ impl DataWriter {
 mod tests {
     use super::*;
     use crate::asset::AssetPool;
-    use crate::fixture::{asset, assets, commodity_id, region_id, time_slice};
+    use crate::fixture::{assets, commodity_id, region_id, time_slice};
     use crate::time_slice::TimeSliceID;
     use itertools::{assert_equal, Itertools};
     use rstest::rstest;
     use std::iter;
     use tempfile::tempdir;
 
     #[rstest]
-    fn test_write_assets(asset: Asset) {
-        let asset = asset.into();
+    fn test_write_assets(assets: AssetPool) {
         let milestone_year = 2020;
         let dir = tempdir().unwrap();
 
         // Write an asset
         {
             let mut writer = DataWriter::create(dir.path(), false).unwrap();
-            writer
-                .write_assets(milestone_year, iter::once(&asset))
-                .unwrap();
+            writer.write_assets(milestone_year, assets.iter()).unwrap();
             writer.flush().unwrap();
         }
 
         // Read back and compare
-        let expected = AssetRow::new(milestone_year, &asset);
+        let asset = assets.iter().next().unwrap();
+        let expected = AssetRow::new(milestone_year, asset);
         let records: Vec<AssetRow> = csv::Reader::from_path(dir.path().join(ASSETS_FILE_NAME))
             .unwrap()
             .into_deserialize()
@@ -364,8 +361,8 @@ mod tests {
     #[rstest]
     fn test_write_flows(assets: AssetPool, commodity_id: CommodityID, time_slice: TimeSliceID) {
         let milestone_year = 2020;
-        let asset = assets.iter().next().unwrap().into();
-        let flow_item = (&asset, &commodity_id, &time_slice, 42.0);
+        let asset = assets.iter().next().unwrap();
+        let flow_item = (asset, &commodity_id, &time_slice, 42.0);
 
         // Write a flow
         let dir = tempdir().unwrap();
@@ -469,13 +466,13 @@ mod tests {
         let milestone_year = 2020;
         let value = 0.5;
         let dir = tempdir().unwrap();
-        let asset = assets.iter().next().unwrap().into();
+        let asset = assets.iter().next().unwrap();
 
         // Write capacity dual
         {
             let mut writer = DebugDataWriter::create(dir.path()).unwrap();
             writer
-                .write_capacity_duals(milestone_year, iter::once((&asset, &time_slice, value)))
+                .write_capacity_duals(milestone_year, iter::once((asset, &time_slice, value)))
                 .unwrap();
             writer.flush().unwrap();
         }

src/simulation/investment.rs

@@ -24,7 +24,7 @@ pub fn perform_agent_investment(
     let mut new_pool = Vec::new();
     for asset in assets.iter() {
         // **TODO**: Implement agent investment. For now, just keep all assets.
-        new_pool.push(asset.clone());
+        new_pool.push(asset.clone().into());
     }
 
     assets.replace_active_pool(new_pool);

src/simulation/optimisation.rs

@@ -184,7 +184,7 @@ fn add_variables(
         for time_slice in model.time_slice_info.iter_ids() {
             let coeff = calculate_cost_coefficient(asset, year, time_slice);
             let var = problem.add_column(coeff, 0.0..);
-            let key = (asset.into(), time_slice.clone());
+            let key = (asset.clone(), time_slice.clone());
             let existing = variables.0.insert(key, var).is_some();
             assert!(!existing, "Duplicate entry for var");
         }