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

pub fn new_future_with_max_decommission( agent_id: AgentID, process: Rc<Process>, region_id: RegionID, capacity: Capacity, commission_year: u32, max_decommission_year: Option<u32>, ) -> Result<Self>

Create a new future asset

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

Create a new future 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 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: &CommodityPrices, 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: &CommodityPrices, 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: &CommodityPrices, 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: &CommodityPrices, 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: &CommodityPrices, 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 CommodityPrices, 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 CommodityPrices, 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_capital_cost_per_activity( &self, annual_activity: Activity, ) -> MoneyPerActivity

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

Total capital costs (cost per capacity * capacity) are shared equally over the year in accordance with the annual activity.

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

Get the annual capital cost per unit of output flow for this asset

Total capital costs (cost per capacity * capacity) 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 is_commissioned(&self) -> bool

Whether this asset has been commissioned

pub fn commission_year(&self) -> u32

Get the commission year for this asset

pub fn decommission_year(&self) -> Option<u32>

Get the decommission 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 group_id(&self) -> Option<AssetGroupID>

Get the group ID for this asset

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

Get the agent ID for this asset

pub fn capacity(&self) -> AssetCapacity

Get the capacity for this asset

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

Set the capacity for this asset (only for Candidate or Selected assets)

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

Increase the capacity for this asset (only for Candidate assets)

fn decommission(&mut self, decommission_year: u32, reason: &str)

Decommission this asset

fn commission( &mut self, id: AssetID, group_id: Option<AssetGroupID>, reason: &str, )

Commission the asset.

Only assets with an AssetState of Future or Selected 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
• reason - The reason for commissioning (included in log)
• group_id - The ID of the group of this asset, if any.

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

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

pub fn mothball(&mut self, year: u32)

Set the year this asset was mothballed

pub fn unmothball(&mut self)

Remove the mothballed year - presumably because the asset has been used

pub fn get_mothballed_year(&self) -> Option<u32>

Get the mothballed year for the asset

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

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

pub fn is_divisible(&self) -> bool

Checks if the asset corresponds to a process that has a unit_size and is therefore divisible.

pub fn divide_asset(&self) -> Vec<AssetRef>

Divides an asset if it is divisible and returns a vector of children

Assets with capacity of type AssetCapacity::Discrete are divided into multiple assets each made up of a single unit of the original asset’s unit size. Will panic if the asset does not have a discrete capacity.

Only Future and Selected assets can be divided.

TODO: To be deleted

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.

impl PartialEq for Asset

fn eq(&self, other: &Asset) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Asset