Struct Asset 

pub struct Asset {
    state: AssetState,
    process: Rc<Process>,
    activity_limits: Rc<ActivityLimits>,
    flows: Rc<IndexMap<CommodityID, ProcessFlow>>,
    process_parameter: Rc<ProcessParameter>,
    region_id: RegionID,
    capacity: AssetCapacity,
    commission_year: u32,
    max_decommission_year: u32,
}

An asset controlled by an agent.

Fields

state: AssetState

The status of the asset

process: Rc<Process>

The Process that this asset corresponds to

activity_limits: Rc<ActivityLimits>

Activity limits for this asset

flows: Rc<IndexMap<CommodityID, ProcessFlow>>

The commodity flows for this asset

process_parameter: Rc<ProcessParameter>

The ProcessParameter corresponding to the asset’s region and commission year

region_id: RegionID

The region in which the asset is located

capacity: AssetCapacity

Capacity of asset (for candidates this is a hypothetical capacity which may be altered)

commission_year: u32

The year the asset was/will be commissioned

max_decommission_year: u32

The maximum year that the asset could be decommissioned

Implementations

impl Asset

pub fn new_candidate( process: Rc<Process>, region_id: RegionID, capacity: Capacity, commission_year: u32, ) -> Result<Self>

Create a new candidate asset

pub fn new_candidate_for_dispatch( process: Rc<Process>, region_id: RegionID, capacity: Capacity, commission_year: u32, ) -> Result<Self>

Create a new candidate for use in dispatch runs

These candidates will have a single continuous capacity specified by the model parameter candidate_asset_capacity, regardless of whether the underlying process is divisible or not.

pub fn new_candidate_from_commissioned(asset: &Asset) -> Self

Create a new candidate asset from a commissioned asset

fn new_with_state( state: AssetState, process: Rc<Process>, region_id: RegionID, capacity: AssetCapacity, commission_year: u32, max_decommission_year: Option<u32>, ) -> Result<Self>

Private helper to create an asset with the given state

pub fn state(&self) -> &AssetState

Get the state of this asset

pub fn process_parameter(&self) -> &ProcessParameter

The process parameter for this asset

pub fn max_decommission_year(&self) -> u32

The last year in which this asset should be decommissioned

pub fn get_activity_per_capacity_limits( &self, time_slice: &TimeSliceID, ) -> RangeInclusive<ActivityPerCapacity>

Get the activity limits per unit of capacity for this asset in a particular time slice

pub fn get_activity_limits_for_selection( &self, time_slice_selection: &TimeSliceSelection, ) -> RangeInclusive<Activity>

Get the activity limits for this asset for a given time slice selection

pub fn get_activity_per_capacity_limits_for_selection( &self, time_slice_selection: &TimeSliceSelection, ) -> RangeInclusive<ActivityPerCapacity>

Get the activity limits per unit of capacity for this asset for a given time slice selection

pub fn iter_activity_limits( &self, ) -> impl Iterator<Item = (TimeSliceSelection, RangeInclusive<Activity>)> + '_

Iterate over activity limits for this asset

pub fn iter_activity_per_capacity_limits( &self, ) -> impl Iterator<Item = (TimeSliceSelection, RangeInclusive<ActivityPerCapacity>)> + '_

Iterate over activity per capacity limits for this asset

pub fn get_total_output_per_activity(&self) -> FlowPerActivity

Gets the total SED/SVD output per unit of activity for this asset

Note: Since we are summing coefficients from different commodities, this ONLY makes sense if these commodities have the same units (e.g., all in PJ). Users are currently not made to give units for commodities, so we cannot possibly enforce this. Something to potentially address in future.

pub fn get_operating_cost( &self, year: u32, time_slice: &TimeSliceID, ) -> MoneyPerActivity

Get the operating cost for this asset in a given year and time slice

pub fn get_revenue_from_flows( &self, prices: &PriceMap, time_slice: &TimeSliceID, ) -> MoneyPerActivity

Get the total revenue from all flows for this asset.

If a price is missing, it is assumed to be zero.

pub fn get_revenue_from_flows_excluding_primary( &self, prices: &PriceMap, time_slice: &TimeSliceID, ) -> MoneyPerActivity

Get the total revenue from all flows excluding the primary output.

If a price is missing, it is assumed to be zero.

pub fn get_input_cost_from_prices( &self, prices: &PriceMap, time_slice: &TimeSliceID, ) -> MoneyPerActivity

Get the total cost of purchasing input commodities per unit of activity for this asset.

If a price is missing, there is assumed to be no cost.

fn get_revenue_from_flows_with_filter<F>( &self, prices: &PriceMap, time_slice: &TimeSliceID, filter_for_flows: F, ) -> MoneyPerActivity

where F: FnMut(&ProcessFlow) -> bool,

Get the total revenue from a subset of flows.

Takes a function as an argument to filter the flows. If a price is missing, it is assumed to be zero.

fn get_generic_activity_cost( &self, prices: &PriceMap, year: u32, time_slice: &TimeSliceID, ) -> MoneyPerActivity

Get the generic activity cost per unit of activity for this asset.

These are all activity-related costs that are not associated with specific SED/SVD outputs. Includes levies, flow costs, costs of inputs and variable operating costs

pub fn iter_marginal_costs_with_filter<'a>( &'a self, prices: &'a PriceMap, year: u32, time_slice: &'a TimeSliceID, filter: impl Fn(&CommodityID) -> bool + 'a, ) -> Box<dyn Iterator<Item = (CommodityID, MoneyPerFlow)> + 'a>

Iterate over marginal costs for a filtered set of SED/SVD output commodities for this asset

For each SED/SVD output commodity, the marginal cost is calculated as the sum of:

• Generic activity costs (variable operating costs, cost of purchasing inputs, plus all levies and flow costs not associated with specific SED/SVD outputs), which are shared equally over all SED/SVD outputs
• Production levies and flow costs for the specific SED/SVD output commodity

pub fn iter_marginal_costs<'a>( &'a self, prices: &'a PriceMap, year: u32, time_slice: &'a TimeSliceID, ) -> Box<dyn Iterator<Item = (CommodityID, MoneyPerFlow)> + 'a>

Iterate over marginal costs for all SED/SVD output commodities for this asset

See iter_marginal_costs_with_filter for details.

pub fn get_annual_capital_cost_per_capacity(&self) -> MoneyPerCapacity

Get the annual capital cost per unit of capacity for this asset

pub fn get_annual_fixed_costs_per_activity( &self, annual_activity: Activity, ) -> MoneyPerActivity

Get the annual fixed costs (AFC) per unit of activity for this asset

Total capital costs and fixed opex are shared equally over the year in accordance with the annual activity.

pub fn get_annual_fixed_costs_per_flow( &self, annual_activity: Activity, ) -> MoneyPerFlow

Get the annual fixed costs (AFC) per unit of output flow for this asset

Total capital costs and fixed opex are shared equally across all output flows in accordance with the annual activity and total output per unit of activity.

pub fn max_activity(&self) -> Activity

Maximum activity for this asset

pub fn get_flow(&self, commodity_id: &CommodityID) -> Option<&ProcessFlow>

Get a specific process flow

pub fn iter_flows(&self) -> impl Iterator<Item = &ProcessFlow>

Iterate over the asset’s flows

pub fn iter_output_flows(&self) -> impl Iterator<Item = &ProcessFlow>

Iterate over the asset’s output SED/SVD flows

pub fn primary_output(&self) -> Option<&ProcessFlow>

Get the primary output flow (if any) for this asset

pub fn primary_output_commodity(&self) -> Option<&CommodityID>

Get the primary output commodity (if any) for this asset

pub fn is_commissioned(&self) -> bool

Whether this asset has been commissioned

pub fn is_candidate(&self) -> bool

Whether this asset is a candidate

pub fn commission_year(&self) -> u32

Get the commission year for this asset

pub fn region_id(&self) -> &RegionID

Get the region ID for this asset

pub fn process(&self) -> &Process

Get the process for this asset

pub fn process_id(&self) -> &ProcessID

Get the process ID for this asset

pub fn id(&self) -> Option<AssetID>

Get the ID for this asset

pub fn is_divisible(&self) -> bool

Whether this asset is divisible

pub fn agent_id(&self) -> Option<&AgentID>

Get the agent ID for this asset, if any

pub fn capacity(&self) -> AssetCapacity

Get the capacity for this asset

pub fn total_capacity(&self) -> Capacity

Get the total capacity for this asset

pub fn set_capacity(&mut self, capacity: AssetCapacity)

Set the capacity of this asset.

Note that this should be done with care!

pub fn increase_capacity(&mut self, capacity: AssetCapacity)

Increase the capacity for this asset

fn commission(&mut self, id: AssetID)

Commission the asset.

Only assets with an AssetState of Ready can be commissioned. If the asset’s state is something else, this function will panic.

Arguments

• id - The ID to give the newly commissioned asset

pub fn select_candidate_for_investment(&mut self, agent_id: AgentID)

Select a Candidate asset for investment, converting it to a Ready state

fn get_mothball_events(&self) -> Option<&VecDeque<MothballEvent>>

Get the mothball events for this asset, if commissioned

fn get_mothball_events_mut(&mut self) -> Option<&mut VecDeque<MothballEvent>>

Get the mothball events (mutably) for this asset, if commissioned

pub fn has_any_mothballed_units(&self) -> bool

Whether this asset has any units mothballed

pub fn get_num_mothballed_units(&self) -> u32

Get the number of units which are mothballed.

For non-commissioned assets, this always returns zero.

pub fn get_num_nonmothballed_units(&self) -> u32

Get the remaining number of units that are not mothballed.

For non-commissioned assets, this always returns the total number of units.

pub fn num_units(&self) -> u32

The number of units this asset represents

If divisible, returns the total number of units, otherwise returns one.

pub fn unit_size(&self) -> Option<Capacity>

Get the unit size for this asset’s capacity (if any)

pub fn max_installable_capacity( &self, commodity_portion: Dimensionless, ) -> Option<AssetCapacity>

For non-commissioned assets, get the maximum capacity permitted to be installed based on the investment constraints for the asset’s process.

The limit is taken from the process’s investment constraints for the asset’s region and commission year, and the portion of the commodity demand being considered.

For divisible assets, the returned capacity will be rounded down to the nearest multiple of the asset’s unit size.

Trait Implementations

impl Clone for Asset

fn clone(&self) -> Asset

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Asset

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Asset> for AssetRef

fn from(value: Asset) -> Self

Converts to this type from the input type.