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,
}

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

Implementations

impl Process

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

Whether the process can be commissioned in a given year

Trait Implementations

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