Merge pull request #888 from EnergySystemsModellingLab/precompute_coefficients

Precompute investment objective coefficients

Author: tsmbland

src/simulation/investment.rs

@@ -18,6 +18,7 @@ use std::collections::HashMap;
 
 pub mod appraisal;
 use appraisal::appraise_investment;
+use appraisal::coefficients::calculate_coefficients_for_assets;
 
 /// A map of demand across time slices for a specific commodity and region
 type DemandMap = IndexMap<TimeSliceID, Flow>;
@@ -364,7 +365,11 @@ fn select_best_assets(
     year: u32,
     writer: &mut DataWriter,
 ) -> Result<Vec<AssetRef>> {
-    let mut best_assets: Vec<AssetRef> = Vec::new();
+    let objective_type = &agent.objectives[&year];
+
+    // Calculate coefficients for all asset options according to the agent's objective
+    let coefficients =
+        calculate_coefficients_for_assets(model, objective_type, &opt_assets, reduced_costs);
 
     let mut remaining_candidate_capacity = HashMap::from_iter(
         opt_assets
@@ -374,7 +379,7 @@ fn select_best_assets(
     );
 
     let mut round = 0;
-    let objective_type = &agent.objectives[&year];
+    let mut best_assets: Vec<AssetRef> = Vec::new();
     while is_any_remaining_demand(&demand) {
         ensure!(
             !opt_assets.is_empty(),
@@ -397,7 +402,7 @@ fn select_best_assets(
                 max_capacity,
                 commodity,
                 objective_type,
-                reduced_costs,
+                &coefficients[asset],
                 &demand,
             )?;
 

src/simulation/investment/appraisal.rs

@@ -5,15 +5,14 @@ use crate::asset::AssetRef;
 use crate::commodity::Commodity;
 use crate::finance::{lcox, profitability_index};
 use crate::model::Model;
-use crate::simulation::prices::ReducedCosts;
 use crate::units::Capacity;
 use anyhow::Result;
 
-mod coefficients;
+pub mod coefficients;
 mod constraints;
 mod costs;
 mod optimisation;
-use coefficients::{calculate_coefficients_for_lcox, calculate_coefficients_for_npv};
+use coefficients::ObjectiveCoefficients;
 use optimisation::perform_optimisation;
 
 /// The output of investment appraisal required to compare potential investment decisions
@@ -37,36 +36,28 @@ fn calculate_lcox(
     asset: &AssetRef,
     max_capacity: Option<Capacity>,
     commodity: &Commodity,
-    reduced_costs: &ReducedCosts,
+    coefficients: &ObjectiveCoefficients,
     demand: &DemandMap,
 ) -> Result<AppraisalOutput> {
-    // Calculate coefficients
-    let coefficients = calculate_coefficients_for_lcox(
-        asset,
-        &model.time_slice_info,
-        reduced_costs,
-        model.parameters.value_of_lost_load,
-    );
-
     // Perform optimisation to calculate capacity, activity and unmet demand
     let results = perform_optimisation(
         asset,
         max_capacity,
         commodity,
-        &coefficients,
+        coefficients,
         demand,
         &model.time_slice_info,
         highs::Sense::Minimise,
     )?;
 
     // Calculate LCOX for the hypothetical investment
     let annual_fixed_cost = coefficients.capacity_coefficient;
-    let activity_costs = coefficients.activity_coefficients;
+    let activity_costs = &coefficients.activity_coefficients;
     let cost_index = lcox(
         results.capacity,
         annual_fixed_cost,
         &results.activity,
-        &activity_costs,
+        activity_costs,
     );
 
     // Return appraisal output
@@ -84,31 +75,28 @@ fn calculate_npv(
     asset: &AssetRef,
     max_capacity: Option<Capacity>,
     commodity: &Commodity,
-    reduced_costs: &ReducedCosts,
+    coefficients: &ObjectiveCoefficients,
     demand: &DemandMap,
 ) -> Result<AppraisalOutput> {
-    // Calculate coefficients
-    let coefficients = calculate_coefficients_for_npv(asset, &model.time_slice_info, reduced_costs);
-
     // Perform optimisation to calculate capacity, activity and unmet demand
     let results = perform_optimisation(
         asset,
         max_capacity,
         commodity,
-        &coefficients,
+        coefficients,
         demand,
         &model.time_slice_info,
         highs::Sense::Maximise,
     )?;
 
     // Calculate profitability index for the hypothetical investment
     let annual_fixed_cost = -coefficients.capacity_coefficient;
-    let activity_surpluses = coefficients.activity_coefficients;
+    let activity_surpluses = &coefficients.activity_coefficients;
     let profitability_index = profitability_index(
         results.capacity,
         annual_fixed_cost,
         &results.activity,
-        &activity_surpluses,
+        activity_surpluses,
     );
 
     // Return appraisal output
@@ -128,12 +116,12 @@ pub fn appraise_investment(
     max_capacity: Option<Capacity>,
     commodity: &Commodity,
     objective_type: &ObjectiveType,
-    reduced_costs: &ReducedCosts,
+    coefficients: &ObjectiveCoefficients,
     demand: &DemandMap,
 ) -> Result<AppraisalOutput> {
     let appraisal_method = match objective_type {
         ObjectiveType::LevelisedCostOfX => calculate_lcox,
         ObjectiveType::NetPresentValue => calculate_npv,
     };
-    appraisal_method(model, asset, max_capacity, commodity, reduced_costs, demand)
+    appraisal_method(model, asset, max_capacity, commodity, coefficients, demand)
 }

src/simulation/investment/appraisal/coefficients.rs

@@ -1,28 +1,60 @@
 //! Calculation of cost coefficients for investment tools.
 use super::costs::{activity_cost, activity_surplus, annual_fixed_cost};
+use crate::agent::ObjectiveType;
 use crate::asset::AssetRef;
+use crate::model::Model;
 use crate::simulation::prices::ReducedCosts;
 use crate::time_slice::{TimeSliceID, TimeSliceInfo};
 use crate::units::{MoneyPerActivity, MoneyPerCapacity, MoneyPerFlow};
 use indexmap::IndexMap;
+use std::collections::HashMap;
 
+/// Map storing cost coefficients for an asset.
+///
+/// These are calculated according to the objective type of the agent owning the asset.
 /// Map storing coefficients for each variable
-pub struct CoefficientsMap {
+pub struct ObjectiveCoefficients {
     /// Cost per unit of capacity
     pub capacity_coefficient: MoneyPerCapacity,
     /// Cost per unit of activity in each time slice
     pub activity_coefficients: IndexMap<TimeSliceID, MoneyPerActivity>,
-    // Unmet demand coefficient
+    /// Unmet demand coefficient
     pub unmet_demand_coefficient: MoneyPerFlow,
 }
 
+/// Calculates cost coefficients for a set of assets for a given objective type.
+pub fn calculate_coefficients_for_assets(
+    model: &Model,
+    objective_type: &ObjectiveType,
+    assets: &[AssetRef],
+    reduced_costs: &ReducedCosts,
+) -> HashMap<AssetRef, ObjectiveCoefficients> {
+    assets
+        .iter()
+        .map(|asset| {
+            let coefficient = match objective_type {
+                ObjectiveType::LevelisedCostOfX => calculate_coefficients_for_lcox(
+                    asset,
+                    &model.time_slice_info,
+                    reduced_costs,
+                    model.parameters.value_of_lost_load,
+                ),
+                ObjectiveType::NetPresentValue => {
+                    calculate_coefficients_for_npv(asset, &model.time_slice_info, reduced_costs)
+                }
+            };
+            (asset.clone(), coefficient)
+        })
+        .collect()
+}
+
 /// Calculates the cost coefficients for LCOX.
 pub fn calculate_coefficients_for_lcox(
     asset: &AssetRef,
     time_slice_info: &TimeSliceInfo,
     reduced_costs: &ReducedCosts,
     value_of_lost_load: MoneyPerFlow,
-) -> CoefficientsMap {
+) -> ObjectiveCoefficients {
     // Capacity coefficient
     let capacity_coefficient = annual_fixed_cost(asset);
 
@@ -36,7 +68,7 @@ pub fn calculate_coefficients_for_lcox(
     // Unmet demand coefficient
     let unmet_demand_coefficient = value_of_lost_load;
 
-    CoefficientsMap {
+    ObjectiveCoefficients {
         capacity_coefficient,
         activity_coefficients,
         unmet_demand_coefficient,
@@ -48,7 +80,7 @@ pub fn calculate_coefficients_for_npv(
     asset: &AssetRef,
     time_slice_info: &TimeSliceInfo,
     reduced_costs: &ReducedCosts,
-) -> CoefficientsMap {
+) -> ObjectiveCoefficients {
     // Capacity coefficient
     let capacity_coefficient = -annual_fixed_cost(asset);
 
@@ -62,7 +94,7 @@ pub fn calculate_coefficients_for_npv(
     // Unmet demand coefficient (we don't apply a cost to unmet demand, so we set this to zero)
     let unmet_demand_coefficient = MoneyPerFlow(0.0);
 
-    CoefficientsMap {
+    ObjectiveCoefficients {
         capacity_coefficient,
         activity_coefficients,
         unmet_demand_coefficient,

src/simulation/investment/appraisal/optimisation.rs

@@ -1,6 +1,6 @@
 //! Optimisation problem for investment tools.
 use super::DemandMap;
-use super::coefficients::CoefficientsMap;
+use super::coefficients::ObjectiveCoefficients;
 use super::constraints::{
     add_activity_constraints, add_capacity_constraint, add_demand_constraints,
 };
@@ -37,7 +37,7 @@ pub struct ResultsMap {
 }
 
 /// Add variables to the problem based on cost coefficients
-fn add_variables(problem: &mut Problem, cost_coefficients: &CoefficientsMap) -> VariableMap {
+fn add_variables(problem: &mut Problem, cost_coefficients: &ObjectiveCoefficients) -> VariableMap {
     // Create capacity variable
     let capacity_var = problem.add_column(cost_coefficients.capacity_coefficient.value(), 0.0..);
 
@@ -98,7 +98,7 @@ pub fn perform_optimisation(
     asset: &AssetRef,
     max_capacity: Option<Capacity>,
     commodity: &Commodity,
-    coefficients: &CoefficientsMap,
+    coefficients: &ObjectiveCoefficients,
     demand: &DemandMap,
     time_slice_info: &TimeSliceInfo,
     sense: Sense,