From 704bdb8e8f4502c96006bac5fb05c5a2b8433171 Mon Sep 17 00:00:00 2001 From: Tom Bland Date: Tue, 10 Nov 2026 15:24:53 +0000 Subject: [PATCH] Refactor price calculation to take activities directly --- benches/assets.rs | 5 +- src/simulation.rs | 18 +++-- src/simulation/activity.rs | 5 +- src/simulation/optimisation.rs | 24 +++--- src/simulation/prices.rs | 141 ++++++++++++++++++++++----------- 5 files changed, 130 insertions(+), 63 deletions(-) diff --git a/benches/assets.rs b/benches/assets.rs index 322c253bc..f56f2d6b7 100644 --- a/benches/assets.rs +++ b/benches/assets.rs @@ -15,7 +15,7 @@ use muse2::simulation::market::{ collect_agent_limits, get_demand_portion_for_market, get_responsible_agents, }; use muse2::simulation::optimisation::DispatchRun; -use muse2::simulation::prices::{Prices, calculate_prices}; +use muse2::simulation::prices::{Prices, calculate_prices_from_solutions}; use rayon::ThreadPoolBuilder; use std::hint::black_box; use std::sync::Arc; @@ -106,10 +106,11 @@ fn calculate_seed_prices( .run("bench setup: with candidates", writer) .expect("Dispatch with candidates failed"); - calculate_prices( + calculate_prices_from_solutions( model, &solution_existing, &solution_with_candidates, + candidates, BASE_YEAR, ) .expect("Failed to calculate prices") diff --git a/src/simulation.rs b/src/simulation.rs index dd7060144..cf10aba07 100644 --- a/src/simulation.rs +++ b/src/simulation.rs @@ -3,7 +3,7 @@ use crate::asset::{Asset, AssetPool, AssetRef}; use crate::model::Model; use crate::output::DataWriter; use crate::process::ProcessMap; -use crate::simulation::prices::{Prices, calculate_prices}; +use crate::simulation::prices::{Prices, calculate_prices_from_solutions}; use crate::timeit::DispatchTimer; use crate::units::Capacity; use anyhow::{Context, Result}; @@ -221,13 +221,19 @@ fn run_dispatch_for_year( solution_with_candidates.as_ref(), ) { (None, None) => Prices::default(), - (Some(existing), None) => calculate_prices(model, existing, existing, year)?, - (Some(existing), Some(with_candidates)) => { - calculate_prices(model, existing, with_candidates, year)? + (Some(existing), None) => { + calculate_prices_from_solutions(model, existing, existing, candidates, year)? } - (None, Some(with_candidates)) => { - calculate_prices(model, with_candidates, with_candidates, year)? + (Some(existing), Some(with_candidates)) => { + calculate_prices_from_solutions(model, existing, with_candidates, candidates, year)? } + (None, Some(with_candidates)) => calculate_prices_from_solutions( + model, + with_candidates, + with_candidates, + candidates, + year, + )?, }; Ok((prices, flow_map)) diff --git a/src/simulation/activity.rs b/src/simulation/activity.rs index 6e5be01f2..6be5236ae 100644 --- a/src/simulation/activity.rs +++ b/src/simulation/activity.rs @@ -2,12 +2,15 @@ use crate::asset::AssetRef; use crate::commodity::CommodityID; use crate::time_slice::TimeSliceID; -use crate::units::{Activity, Flow}; +use crate::units::{Activity, Flow, MoneyPerActivity}; use indexmap::IndexMap; /// A map of asset activities in each time slice pub type ActivityMap = IndexMap<(AssetRef, TimeSliceID), Activity>; +/// A map of the dual values of asset activity constraints in each time slice +pub type ActivityDualMap = IndexMap<(AssetRef, TimeSliceID), MoneyPerActivity>; + /// A map of commodity flows for assets in each time slice pub type FlowMap = IndexMap<(AssetRef, CommodityID, TimeSliceID), Flow>; diff --git a/src/simulation/optimisation.rs b/src/simulation/optimisation.rs index 6714d50b3..6548b9707 100644 --- a/src/simulation/optimisation.rs +++ b/src/simulation/optimisation.rs @@ -8,7 +8,7 @@ use crate::model::Model; use crate::output::DataWriter; use crate::region::RegionID; use crate::simulation::PriceMap; -use crate::simulation::activity::{FlowMap, create_flow_map}; +use crate::simulation::activity::{ActivityDualMap, ActivityMap, FlowMap, create_flow_map}; use crate::simulation::investment::AllDemandMap; use crate::time_slice::{TimeSliceID, TimeSliceInfo, TimeSliceSelection}; use crate::units::{Activity, Flow, Money, MoneyPerActivity, MoneyPerFlow}; @@ -200,6 +200,13 @@ impl Solution<'_> { .map(|((asset, time_slice), &value)| (asset, time_slice, Activity(value))) } + /// Activity for each existing asset, as an [`ActivityMap`] + pub fn activity_map_for_existing(&self) -> ActivityMap { + self.iter_activity_for_existing() + .map(|(asset, time_slice, activity)| ((asset.clone(), time_slice.clone()), activity)) + .collect() + } + /// Activity for each candidate asset pub fn iter_activity_for_candidates( &self, @@ -212,14 +219,6 @@ impl Solution<'_> { .map(|((asset, time_slice), &value)| (asset, time_slice, Activity(value))) } - /// Iterate over the keys for activity for each candidate asset - pub fn iter_activity_keys_for_candidates( - &self, - ) -> impl Iterator { - self.iter_activity_for_candidates() - .map(|(asset, time_slice, _activity)| (asset, time_slice)) - } - /// Iterate over unmet demand pub fn iter_unmet_demand( &self, @@ -270,6 +269,13 @@ impl Solution<'_> { }) } + /// Dual values for activity constraints, as an [`ActivityDualMap`] + pub fn activity_dual_map(&self) -> ActivityDualMap { + self.iter_activity_duals() + .map(|(asset, time_slice, dual)| ((asset.clone(), time_slice.clone()), dual)) + .collect() + } + /// Keys and values for column duals. pub fn iter_column_duals( &self, diff --git a/src/simulation/prices.rs b/src/simulation/prices.rs index 3daf044a3..f556e1e1c 100644 --- a/src/simulation/prices.rs +++ b/src/simulation/prices.rs @@ -5,12 +5,14 @@ use crate::asset::AssetRef; use crate::commodity::{CommodityID, CommodityMap, CommodityType, PricingStrategy}; use crate::model::Model; use crate::region::RegionID; +use crate::simulation::activity::{ActivityDualMap, ActivityMap}; use crate::simulation::market::MarketSet; use crate::simulation::optimisation::Solution; use crate::time_slice::{TimeSliceID, TimeSliceInfo, TimeSliceSelection}; use crate::units::{Activity, Dimensionless, Flow, MoneyPerActivity, MoneyPerFlow, UnitType, Year}; use anyhow::Result; use indexmap::IndexMap; +use itertools::iproduct; use std::collections::{HashMap, HashSet}; use std::marker::PhantomData; @@ -62,6 +64,37 @@ pub struct Prices { pub fallback: PriceMap, } +/// Calculate commodity prices from the solutions to dispatch optimisations. +/// +/// This extracts the activities of existing assets from `solution_without_candidates` and the dual +/// values from `solution_with_candidates`, then calls [`calculate_prices`]. +/// +/// # Arguments +/// +/// * `model` - The model +/// * `solution_without_candidates` - Solution to dispatch optimisation without candidates +/// * `solution_with_candidates` - Solution to dispatch optimisation with candidates +/// * `candidates` - The candidate assets included in `solution_with_candidates`, if any +/// * `year` - The year for which prices are being calculated +pub fn calculate_prices_from_solutions( + model: &Model, + solution_without_candidates: &Solution, + solution_with_candidates: &Solution, + candidates: &[AssetRef], + year: u32, +) -> Result { + // Shadow prices come from the solution _with_ candidates, so that we can get them for + // commodities not produced/consumed by any existing assets. + calculate_prices( + model, + &solution_without_candidates.activity_map_for_existing(), + candidates, + PriceMap::from_iter(solution_with_candidates.iter_commodity_balance_duals()), + &solution_with_candidates.activity_dual_map(), + year, + ) +} + /// Calculate commodity prices. /// /// Calculate prices for each commodity/region/time-slice according to the commodity's configured @@ -70,8 +103,13 @@ pub struct Prices { /// # Arguments /// /// * `model` - The model -/// * `solution_without_candidates` - Solution to dispatch optimisation without candidates -/// * `solution_with_candidates` - Solution to dispatch optimisation with candidates +/// * `activity` - Activity of existing assets in each time slice +/// * `candidates` - Candidate assets +/// * `shadow_prices` - Shadow prices for all SED/SVD commodities. These should be derived from a +/// dispatch that includes candidates, so that commodities not produced/consumed by any existing +/// assets get prices. +/// * `activity_duals` - Dual values of the activity constraints for assets (only used for +/// scarcity-adjusted pricing) /// * `year` - The year for which prices are being calculated /// /// # Returns @@ -79,16 +117,12 @@ pub struct Prices { /// Market prices for commodities as well as shadow prices. pub fn calculate_prices( model: &Model, - solution_without_candidates: &Solution, - solution_with_candidates: &Solution, + activity: &ActivityMap, + candidates: &[AssetRef], + shadow_prices: PriceMap, + activity_duals: &ActivityDualMap, year: u32, ) -> Result { - // Collect shadow prices for all SED/SVD commodities - // These are derived from the dispatch solution _with_ candidates, so that we can get shadow - // prices for commodities not produced/consumed by any existing assets. - let shadow_prices = - PriceMap::from_iter(solution_with_candidates.iter_commodity_balance_duals()); - // Set up empty market prices map let mut market_prices = PriceMap::default(); @@ -103,8 +137,9 @@ pub fn calculate_prices( price_market_set( market_set, model, - solution_without_candidates, - solution_with_candidates, + activity, + candidates, + activity_duals, year, &shadow_prices, &mut annual_activities, @@ -115,8 +150,9 @@ pub fn calculate_prices( price_market_set( market_set, model, - solution_without_candidates, - solution_with_candidates, + activity, + candidates, + activity_duals, year, &shadow_prices, &mut annual_activities, @@ -138,8 +174,9 @@ pub fn calculate_prices( fn price_market_set( market_set: &MarketSet, model: &Model, - solution_without_candidates: &Solution, - solution_with_candidates: &Solution, + activity: &ActivityMap, + candidates: &[AssetRef], + activity_duals: &ActivityDualMap, year: u32, shadow_prices: &PriceMap, annual_activities: &mut Option>, @@ -150,8 +187,9 @@ fn price_market_set( MarketSet::Single(market) => { price_markets( model, - solution_without_candidates, - solution_with_candidates, + activity, + candidates, + activity_duals, year, std::slice::from_ref(market), shadow_prices, @@ -163,8 +201,9 @@ fn price_market_set( MarketSet::Cycle { markets, .. } => { price_cycle( model, - solution_without_candidates, - solution_with_candidates, + activity, + candidates, + activity_duals, year, markets, shadow_prices, @@ -178,8 +217,9 @@ fn price_market_set( price_market_set( set, model, - solution_without_candidates, - solution_with_candidates, + activity, + candidates, + activity_duals, year, shadow_prices, annual_activities, @@ -199,8 +239,9 @@ fn price_market_set( /// # Arguments /// /// * `model` - The model -/// * `solution_without_candidates` - Solution to dispatch optimisation without candidate activities -/// * `solution_with_candidates` - Solution to dispatch optimisation with candidate activities +/// * `activity` - Activity of existing assets in each time slice +/// * `candidates` - Candidate assets +/// * `activity_duals` - Dual values of the activity constraints for assets /// * `year` - The year for which prices are being calculated /// * `markets` - The markets to calculate prices for /// * `shadow_prices` - Shadow prices for all commodities @@ -212,8 +253,9 @@ fn price_market_set( #[allow(clippy::too_many_arguments)] fn price_markets( model: &Model, - solution_without_candidates: &Solution, - solution_with_candidates: &Solution, + activity: &ActivityMap, + candidates: &[AssetRef], + activity_duals: &ActivityDualMap, year: u32, markets: &[(CommodityID, RegionID)], shadow_prices: &PriceMap, @@ -221,6 +263,13 @@ fn price_markets( market_prices: &mut PriceMap, strategy_override: Option, ) { + let existing_activity = || { + activity + .iter() + .map(|((asset, time_slice), activity)| (asset, time_slice, *activity)) + }; + let candidate_activity_keys = || iproduct!(candidates, model.time_slice_info.iter_ids()); + // Partition markets by pricing strategy into a map keyed by `PricingStrategy`. let mut pricing_sets = HashMap::new(); for (commodity_id, region_id) in markets { @@ -260,7 +309,9 @@ fn price_markets( // Add prices for scarcity-adjusted commodities if let Some(scarcity_set) = pricing_sets.get(&PricingStrategy::ScarcityAdjusted) { add_scarcity_adjusted_prices( - solution_with_candidates.iter_activity_duals(), + activity_duals + .iter() + .map(|((asset, time_slice), dual)| (asset, time_slice, *dual)), shadow_prices, market_prices, scarcity_set, @@ -270,8 +321,8 @@ fn price_markets( // Add prices for marginal cost commodities if let Some(marginal_set) = pricing_sets.get(&PricingStrategy::MarginalCost) { add_marginal_cost_prices( - solution_without_candidates.iter_activity_for_existing(), - solution_with_candidates.iter_activity_keys_for_candidates(), + existing_activity(), + candidate_activity_keys(), market_prices, year, marginal_set, @@ -283,8 +334,8 @@ fn price_markets( // Add prices for marginal average commodities if let Some(marginal_avg_set) = pricing_sets.get(&PricingStrategy::MarginalCostAverage) { add_marginal_cost_average_prices( - solution_without_candidates.iter_activity_for_existing(), - solution_with_candidates.iter_activity_keys_for_candidates(), + existing_activity(), + candidate_activity_keys(), market_prices, year, marginal_avg_set, @@ -295,12 +346,11 @@ fn price_markets( // Add prices for full cost commodities if let Some(fullcost_set) = pricing_sets.get(&PricingStrategy::FullCost) { - let annual_activities = annual_activities.get_or_insert_with(|| { - calculate_annual_activities(solution_without_candidates.iter_activity_for_existing()) - }); + let annual_activities = annual_activities + .get_or_insert_with(|| calculate_annual_activities(existing_activity())); add_full_cost_prices( - solution_without_candidates.iter_activity_for_existing(), - solution_with_candidates.iter_activity_keys_for_candidates(), + existing_activity(), + candidate_activity_keys(), annual_activities, market_prices, year, @@ -312,12 +362,11 @@ fn price_markets( // Add prices for full average commodities if let Some(full_avg_set) = pricing_sets.get(&PricingStrategy::FullCostAverage) { - let annual_activities = annual_activities.get_or_insert_with(|| { - calculate_annual_activities(solution_without_candidates.iter_activity_for_existing()) - }); + let annual_activities = annual_activities + .get_or_insert_with(|| calculate_annual_activities(existing_activity())); add_full_cost_average_prices( - solution_without_candidates.iter_activity_for_existing(), - solution_with_candidates.iter_activity_keys_for_candidates(), + existing_activity(), + candidate_activity_keys(), annual_activities, market_prices, year, @@ -337,8 +386,9 @@ fn price_markets( #[allow(clippy::too_many_arguments)] fn price_cycle( model: &Model, - solution_without_candidates: &Solution, - solution_with_candidates: &Solution, + activity: &ActivityMap, + candidates: &[AssetRef], + activity_duals: &ActivityDualMap, year: u32, markets: &[(CommodityID, RegionID)], shadow_prices: &PriceMap, @@ -361,8 +411,9 @@ fn price_cycle( for market in markets.iter().rev() { price_markets( model, - solution_without_candidates, - solution_with_candidates, + activity, + candidates, + activity_duals, year, std::slice::from_ref(market), shadow_prices,