Struct Process 

pub struct Process {
    pub id: ProcessID,
    pub description: String,
    pub years: RangeInclusive<u32>,
    pub activity_limits: ProcessActivityLimitsMap,
    pub flows: ProcessFlowsMap,
    pub parameters: ProcessParameterMap,
    pub regions: IndexSet<RegionID>,
    pub primary_output: Option<CommodityID>,
    pub capacity_to_activity: ActivityPerCapacity,
    pub investment_constraints: ProcessInvestmentConstraintsMap,
    pub tranche_size: Option<Capacity>,
}

Represents a process within the simulation

Fields

id: ProcessID

A unique identifier for the process (e.g. GASDRV)

description: String

A human-readable description for the process (e.g. dry gas extraction)

years: RangeInclusive<u32>

The years in which this process is available for investment.

activity_limits: ProcessActivityLimitsMap

Limits on activity for each time slice (as a fraction of maximum)

flows: ProcessFlowsMap

Maximum annual commodity flows for this process

parameters: ProcessParameterMap

Additional parameters for this process

regions: IndexSet<RegionID>

The regions in which this process can operate

primary_output: Option<CommodityID>

The primary output for this process, if any

capacity_to_activity: ActivityPerCapacity

Factor for calculating the maximum consumption/production over a year.

Used for converting one unit of capacity to maximum energy of asset per year. For example, if capacity is measured in GW and energy is measured in PJ, the capacity_to_activity for the process is 31.536 because 1 GW of capacity can produce 31.536 PJ energy output in a year.

investment_constraints: ProcessInvestmentConstraintsMap

Investment constraints for this process

tranche_size: Option<Capacity>

Capacity of each tranche for investments in this process, if any.

Candidate assets are created with one tranche of this size, and MUSE2 may select multiple tranches over successive investment rounds. For user-provided assets, this value determines how their total capacity is represented as equal-capacity tranches; the number of tranches is rounded up when necessary.

Implementations

impl Process

pub fn active_for_year(&self, year: u32) -> bool

Whether the process can be commissioned in a given year

fn agent_limit( &self, region_id: &RegionID, commission_year: u32, commodity_portion: Dimensionless, get_limit: fn(&ProcessInvestmentConstraint) -> Option<Capacity>, ) -> Option<Capacity>

Calculate an agent’s share of any limit for this process in a region and year based on commodity portion.

pub fn agent_addition_limit( &self, region_id: &RegionID, commission_year: u32, commodity_portion: Dimensionless, ) -> Option<Capacity>

Calculate an agent’s share of the addition limit for this process in a region and year based on commodity portion.

pub fn agent_total_limit( &self, region_id: &RegionID, commission_year: u32, commodity_portion: Dimensionless, ) -> Option<Capacity>

Calculate an agent’s share of the total limit for this process in a region and year based on commodity portion.

Trait Implementations

impl Clone for Process

fn clone(&self) -> Process

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Process

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

Formats the value using the given formatter.

impl PartialEq for Process

fn eq(&self, other: &Process) -> 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 Process