Allow for output without graph validation

Author: tsmbland

src/cli.rs

@@ -1,7 +1,7 @@
 //! The command line interface for the simulation.
-use crate::graph::save_commodity_graphs_for_model;
-use crate::input::load_model;
+use crate::input::{load_commodity_graphs, load_model};
 use crate::log;
+use crate::output::graph::save_commodity_graphs_for_model;
 use crate::output::{create_output_directory, get_output_dir};
 use crate::settings::Settings;
 use ::log::{info, warn};
@@ -207,12 +207,9 @@ pub fn handle_build_commodity_graphs_command(
     // Initialise program logger (we won't save log files when running the validate command)
     log::init(&settings.log_level, None).context("Failed to initialise logging.")?;
 
-    // Load/validate the model
-    let (model, _) = load_model(model_path).context("Failed to load model.")?;
-    info!("Loaded model from {}", model_path.display());
-
-    // Save commodity flow graphs to file
-    save_commodity_graphs_for_model(&model.commodity_graphs, output_path)?;
+    // Load commodity flow graphs and save to file
+    let commodity_graphs = load_commodity_graphs(model_path)?;
+    save_commodity_graphs_for_model(&commodity_graphs, output_path)?;
     info!("Commodity flow graphs saved to file");
 
     Ok(())

src/graph.rs

@@ -12,7 +12,6 @@ use petgraph::algo::toposort;
 use petgraph::graph::Graph;
 use std::collections::HashMap;
 use std::fmt::Display;
-use std::path::Path;
 use strum::IntoEnumIterator;
 
 /// A graph of commodity flows for a given region and year
@@ -51,6 +50,15 @@ pub enum GraphEdge {
     Demand,
 }
 
+impl Display for GraphEdge {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GraphEdge::Process(id) => write!(f, "{id}"),
+            GraphEdge::Demand => write!(f, "DEMAND"),
+        }
+    }
+}
+
 /// Creates a directed graph of commodity flows for a given region and year.
 ///
 /// The graph contains nodes for all commodities that may be consumed/produced by processes in the
@@ -401,19 +409,6 @@ pub fn validate_commodity_graphs_for_model(
     Ok(commodity_order)
 }
 
-/// Saves commodity graphs to file
-///
-/// The graphs are saved as DOT files to the specified output path
-pub fn save_commodity_graphs_for_model(
-    commodity_graphs: &HashMap<(RegionID, u32), CommoditiesGraph>,
-    _output_path: &Path,
-) -> Result<()> {
-    for ((_region_id, _year), _graph) in commodity_graphs {
-        todo!()
-    }
-    Ok(())
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/input.rs

@@ -1,8 +1,11 @@
 //! Common routines for handling input data.
 use crate::asset::AssetPool;
-use crate::graph::{build_commodity_graphs_for_model, validate_commodity_graphs_for_model};
+use crate::graph::{
+    CommoditiesGraph, build_commodity_graphs_for_model, validate_commodity_graphs_for_model,
+};
 use crate::id::{HasID, IDLike};
 use crate::model::{Model, ModelParameters};
+use crate::region::RegionID;
 use crate::units::UnitType;
 use anyhow::{Context, Result, bail, ensure};
 use float_cmp::approx_eq;
@@ -233,12 +236,46 @@ pub fn load_model<P: AsRef<Path>>(model_dir: P) -> Result<(Model, AssetPool)> {
         processes,
         time_slice_info,
         regions,
-        commodity_graphs,
         commodity_order,
     };
     Ok((model, AssetPool::new(assets)))
 }
 
+/// Load commodity flow graphs for a model.
+///
+/// This begins by reading time slice, region, year, commodity and process data which is necessary
+/// to build the graphs. Other model data (agents and assets) that is not necessary for graph
+/// building is not read.
+///
+/// Once data is loaded (and assuming the validation checks for this data pass), this will create a
+/// graph of commodity flows for each region and year, where nodes are commodities and edges are
+/// processes.
+///
+/// Graphs validation is NOT performed. This ensures that graphs can be generated even when
+/// validation would fail, which may be helpful for debugging.
+pub fn load_commodity_graphs<P: AsRef<Path>>(
+    model_dir: P,
+) -> Result<HashMap<(RegionID, u32), CommoditiesGraph>> {
+    let model_params = ModelParameters::from_path(&model_dir)?;
+
+    let time_slice_info = read_time_slice_info(model_dir.as_ref())?;
+    let regions = read_regions(model_dir.as_ref())?;
+    let region_ids = regions.keys().cloned().collect();
+    let years = &model_params.milestone_years;
+
+    let commodities = read_commodities(model_dir.as_ref(), &region_ids, &time_slice_info, years)?;
+    let processes = read_processes(
+        model_dir.as_ref(),
+        &commodities,
+        &region_ids,
+        &time_slice_info,
+        years,
+    )?;
+
+    let commodity_graphs = build_commodity_graphs_for_model(&processes, &region_ids, years)?;
+    Ok(commodity_graphs)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/model.rs

@@ -1,7 +1,6 @@
 //! The model represents the static input data provided by the user.
 use crate::agent::AgentMap;
 use crate::commodity::{CommodityID, CommodityMap};
-use crate::graph::CommoditiesGraph;
 use crate::process::ProcessMap;
 use crate::region::{RegionID, RegionMap};
 use crate::time_slice::TimeSliceInfo;
@@ -27,8 +26,6 @@ pub struct Model {
     pub time_slice_info: TimeSliceInfo,
     /// Regions for the simulation
     pub regions: RegionMap,
-    /// Commodity flow graphs for each region and year
-    pub commodity_graphs: HashMap<(RegionID, u32), CommoditiesGraph>,
     /// Commodity ordering for each region and year
     pub commodity_order: HashMap<(RegionID, u32), Vec<CommodityID>>,
 }

src/output.rs

@@ -17,6 +17,7 @@ use std::fs;
 use std::fs::File;
 use std::path::{Path, PathBuf};
 
+pub mod graph;
 pub mod metadata;
 use metadata::write_metadata;
 

src/output/graph.rs

@@ -0,0 +1,24 @@
+//! The module responsible for writing commodity flow graphs to file.
+use crate::graph::CommoditiesGraph;
+use crate::region::RegionID;
+use anyhow::Result;
+use petgraph::dot::Dot;
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::Write as IoWrite;
+use std::path::Path;
+
+/// Saves commodity graphs to file
+///
+/// The graphs are saved as DOT files to the specified output path
+pub fn save_commodity_graphs_for_model(
+    commodity_graphs: &HashMap<(RegionID, u32), CommoditiesGraph>,
+    output_path: &Path,
+) -> Result<()> {
+    for ((region_id, year), graph) in commodity_graphs {
+        let dot = Dot::new(&graph);
+        let mut file = File::create(output_path.join(format!("{region_id}_{year}.dot")))?;
+        write!(file, "{dot}")?;
+    }
+    Ok(())
+}