Remove PACs from code and documentation

Closes #596.

Author: alexdewar

docs/glossary.md

@@ -2,9 +2,7 @@
 
 **Activity:** The flow of input/s or output/s of a *Process* that are limited by its capacity. For
 example, a 500MW power station can output 500MWh per hour of electrical power, or a 50MW
-electrolyser consumes up to 50MWh per hour of electrical power to produce hydrogen. The
-*Primary Activity Commodity* specifies which output/s or input/s are linked to the *Process*
-capacity.
+electrolyser consumes up to 50MWh per hour of electrical power to produce hydrogen.
 
 **Agent:** A decision-making entity in the system. An *Agent* is responsible for serving a
 user-specified portion of a *Commodity* demand or *Service Demand*. *Agents* invest in and operate
@@ -27,14 +25,9 @@ data, including **Process** stock and commodity consumption/production.
 **Calibration:** The act of ensuring that the model represents the system being modelled in a
 historical base year.
 
-**Capacity:** The maximum output (or input) of an *Asset*, as measured by units of the *Primary
-Activity Commodity*.
+**Capacity:** The maximum output (or input) of an *Asset*.
 
-**Capital Cost:** The overnight capital cost of a process, measured in units of the *Primary
-Activity Commodity* divided by CAP2ACT. CAP2ACT is a factor that converts 1 unit of capacity to
-maximum activity of the primary activity commodity/ies per year. For example, if capacity is
-measured in GW and activity is measured in PJ, CAP2ACT for the process is 31.536 because 1 GW of
-capacity can produce 31.536 PJ energy output in a year.
+**Capital Cost:** The overnight capital cost of a process.
 
 <!-- markdownlint-disable-next-line MD033 -->
 **Commodity:** A substance (e.g. CO<sub>2</sub>) or form of energy (e.g. electricity) that can be
@@ -79,10 +72,6 @@ the next most expensive, etc, until demand is served. Also called “unit commit
 
 **Output Commodity/ies:** The commodities that flow out of a *Process*.
 
-**Primary Activity Commodity (PAC):** The PACs specify which output/s are linked to the *Process*
-capacity. The combined output of all PACs cannot exceed the *Asset's* capacity. A user can define
-which output/s are PACs. Most, but not all *Process*es will have only one PAC.
-
 **Process:** A blueprint of an available *Process* that converts input commodities to output
 commodities. *Process*es have economic attributes of capital cost, fixed operating cost per unit
 capacity, non-fuel variable operating cost per unit activity, and risk discount rate. They have
@@ -114,9 +103,8 @@ Levelised Cost of X, etc.
 a model does not represent seasons or within-day (diurnal) variation). A typical model will have
 several diurnal time slices, and several seasonal time slices.
 
-**Utilisation:** The percentage of an *Asset*s capacity that is actually used to produce *Primary
-Activity Commodities*. Must be between 0 and 1, and can be measured at time slice, season, or year
-level.
+**Utilisation:** The percentage of an *Asset*'s capacity that is actually used to produce its
+commodities. Must be between 0 and 1, and can be measured at time slice, season, or year level.
 
 **Variable Operating Cost:** The variable operating cost charged per unit of input or output of the
-*Primary Activity Commodity* of the *Process*.
+ *Process*.

schemas/input/process_flows.yaml

@@ -3,9 +3,6 @@ description: |
   Commodity flows can vary by region and year. For each process, there must be entries covering all
   the years and regions in which the process operates.
 
-  One (and only one) commodity flow for each region/year must be designated as the primary activity
-  commodity (PAC).
-
 fields:
   - name: process_id
     type: string
@@ -36,9 +33,3 @@ fields:
     type: number
     title: The cost per unit flow
     description: Optional. If present, must be >0.
-  - name: is_pac
-    type: boolean
-    title: Whether this commodity flow is a primary activity commodity (PAC)
-    description: |
-      One and only one commodity flow can be a PAC for a given combination of region and milestone
-      year

schemas/input/process_parameters.yaml

@@ -27,7 +27,7 @@ fields:
     title: Annual operating cost per unit capacity
   - name: variable_operating_cost
     type: number
-    title: Annual variable operating cost per unit activity, for PACs **only**
+    title: Annual variable operating cost per unit activity
   - name: lifetime
     type: integer
     title: Lifetime in years of an asset created from this process
@@ -38,5 +38,5 @@ fields:
     description: Must be positive. A warning will be issued if this number is >1.
   - name: capacity_to_activity
     type: number
-    title: Factor for calculating the maximum PAC consumption/production over a year.
+    title: Factor for calculating the maximum consumption/production over a year.
     description: Must be >=0

src/asset.rs

@@ -86,7 +86,7 @@ impl Asset {
 
     /// Get the energy limits for this asset in a particular time slice
     ///
-    /// This is an absolute max and min on the PAC energy produced/consumed in that time slice.
+    /// This is an absolute max and min on the energy produced/consumed in that time slice.
     pub fn get_energy_limits(&self, time_slice: &TimeSliceID) -> RangeInclusive<f64> {
         let limits = self
             .process
@@ -104,7 +104,7 @@ impl Asset {
         (max_act * limits.start())..=(max_act * limits.end())
     }
 
-    /// Maximum activity for this asset (PAC energy produced/consumed per year)
+    /// Maximum activity for this asset (energy produced/consumed per year)
     pub fn maximum_activity(&self) -> f64 {
         self.capacity * self.process_parameter.capacity_to_activity
     }
@@ -126,12 +126,6 @@ impl Asset {
     pub fn iter_flows(&self) -> impl Iterator<Item = &ProcessFlow> {
         self.get_flows_map().values()
     }
-
-    /// Iterate over the asset's Primary Activity Commodity flows
-    pub fn iter_pacs(&self) -> impl Iterator<Item = &ProcessFlow> {
-        self.process
-            .iter_pacs(&self.region_id, self.commission_year)
-    }
 }
 
 /// A wrapper around [`Asset`] for storing references in maps.

src/input/process.rs

@@ -308,7 +308,6 @@ mod tests {
                 coeff: -10.0,
                 kind: FlowType::Fixed,
                 cost: 1.0,
-                is_pac: false,
             }},
         )])
     }
@@ -322,7 +321,6 @@ mod tests {
                 coeff: 10.0,
                 kind: FlowType::Fixed,
                 cost: 1.0,
-                is_pac: false,
             }},
         )])
     }
@@ -383,7 +381,6 @@ mod tests {
                     coeff: 10.0,
                     kind: FlowType::Fixed,
                     cost: 1.0,
-                    is_pac: false,
                 }},
             )]),
         )])

src/input/process/availability.rs

@@ -39,8 +39,8 @@ impl ProcessAvailabilityRaw {
 
     /// Calculate fraction of annual energy as availability multiplied by time slice length.
     ///
-    /// The resulting limits are max/min PAC energy produced/consumed in each timeslice per
-    /// cap2act units of capacity
+    /// The resulting limits are max/min energy produced/consumed in each timeslice per
+    /// `capacity_to_activity` units of capacity.
     fn to_bounds(&self, ts_length: f64) -> RangeInclusive<f64> {
         let value = self.value * ts_length;
         match self.limit_type {

src/input/process/flow.rs

@@ -1,6 +1,6 @@
 //! Code for reading process flows file
 use super::super::*;
-use crate::commodity::{CommodityID, CommodityMap};
+use crate::commodity::CommodityMap;
 use crate::id::IDCollection;
 use crate::process::{FlowType, Process, ProcessFlow, ProcessFlowsMap, ProcessID};
 use crate::region::parse_region_str;
@@ -25,7 +25,6 @@ struct ProcessFlowRaw {
     #[serde(rename = "type")]
     kind: FlowType,
     cost: Option<f64>,
-    is_pac: bool,
 }
 
 impl ProcessFlowRaw {
@@ -112,7 +111,6 @@ where
             coeff: record.coeff,
             kind: record.kind,
             cost: record.cost.unwrap_or(0.0),
-            is_pac: record.is_pac,
         };
 
         // Insert flow into the map
@@ -134,63 +132,26 @@ where
         }
     }
 
-    // Validate flows and sort flows so PACs are at the start
     for (process_id, map) in map.iter_mut() {
         let process = processes.get(process_id).unwrap();
         validate_process_flows_map(process, map)?;
-        sort_flows(map);
     }
 
     Ok(map)
 }
 
-/// Sort flows so PACs come first
-fn sort_flows(map: &mut ProcessFlowsMap) {
-    for map in map.values_mut() {
-        map.sort_by(|_, a, _, b| b.is_pac.cmp(&a.is_pac));
-    }
-}
-
 /// Validate flows for a process
 fn validate_process_flows_map(process: &Process, map: &ProcessFlowsMap) -> Result<()> {
     let process_id = process.id.clone();
-    let reference_years = &process.years;
-    let reference_regions = &process.regions;
-    for year in reference_years.iter() {
-        for region in reference_regions {
+    for year in process.years.iter() {
+        for region in process.regions.iter() {
             // Check that the process has flows for this region/year
-            let flow_map = map.get(&(region.clone(), *year)).with_context(|| {
-                format!("Missing entry for process {process_id} in {region}/{year}")
-            })?;
-
-            // Validate flows for this process/region/year
-            validate_flow_map(flow_map).with_context(|| {
-                format!("Invalid flows for process {process_id} in {region}/{year}")
-            })?;
-        }
-    }
-    Ok(())
-}
-
-/// Validate a vector of flows for a process in a given region/year
-fn validate_flow_map(flow_map: &IndexMap<CommodityID, ProcessFlow>) -> Result<()> {
-    // PACs must be either all inputs or all outputs
-    let mut flow_sign: Option<bool> = None; // False for inputs, true for outputs
-    for flow in flow_map.values().filter(|flow| flow.is_pac) {
-        // Check that flow sign is consistent
-        let current_flow_sign = flow.coeff > 0.0;
-        if let Some(flow_sign) = flow_sign {
             ensure!(
-                current_flow_sign == flow_sign,
-                "PACs are a mix of inputs and outputs",
+                map.contains_key(&(region.clone(), *year)),
+                "Missing entry for process {process_id} in {region}/{year}"
             );
         }
-        flow_sign = Some(current_flow_sign);
     }
-
-    // Check that at least one PAC is defined
-    ensure!(flow_sign.is_some(), "No PACs defined");
-
     Ok(())
 }
 
@@ -199,15 +160,10 @@ mod tests {
     use super::*;
     use crate::commodity::{Commodity, CommodityLevyMap, CommodityType, DemandMap};
     use crate::time_slice::TimeSliceLevel;
-    use indexmap::indexmap;
-    use rstest::{fixture, rstest};
 
-    fn create_process_flow_raw(
-        coeff: f64,
-        kind: FlowType,
-        cost: Option<f64>,
-        is_pac: bool,
-    ) -> ProcessFlowRaw {
+    use rstest::fixture;
+
+    fn create_process_flow_raw(coeff: f64, kind: FlowType, cost: Option<f64>) -> ProcessFlowRaw {
         ProcessFlowRaw {
             process_id: "process".into(),
             commodity_id: "commodity".into(),
@@ -216,45 +172,34 @@ mod tests {
             coeff,
             kind,
             cost,
-            is_pac,
         }
     }
 
     #[test]
     fn test_validate_flow_raw() {
         // Valid
-        let valid = create_process_flow_raw(1.0, FlowType::Fixed, Some(0.0), true);
+        let valid = create_process_flow_raw(1.0, FlowType::Fixed, Some(0.0));
         assert!(valid.validate().is_ok());
 
         // Invalid: Bad flow value
-        let invalid = create_process_flow_raw(0.0, FlowType::Fixed, Some(0.0), true);
+        let invalid = create_process_flow_raw(0.0, FlowType::Fixed, Some(0.0));
         assert!(invalid.validate().is_err());
-        let invalid = create_process_flow_raw(f64::NAN, FlowType::Fixed, Some(0.0), true);
+        let invalid = create_process_flow_raw(f64::NAN, FlowType::Fixed, Some(0.0));
         assert!(invalid.validate().is_err());
-        let invalid = create_process_flow_raw(f64::INFINITY, FlowType::Fixed, Some(0.0), true);
+        let invalid = create_process_flow_raw(f64::INFINITY, FlowType::Fixed, Some(0.0));
         assert!(invalid.validate().is_err());
-        let invalid = create_process_flow_raw(f64::NEG_INFINITY, FlowType::Fixed, Some(0.0), true);
+        let invalid = create_process_flow_raw(f64::NEG_INFINITY, FlowType::Fixed, Some(0.0));
         assert!(invalid.validate().is_err());
 
         // Invalid: Bad flow cost value
-        let invalid = create_process_flow_raw(1.0, FlowType::Fixed, Some(f64::NAN), true);
+        let invalid = create_process_flow_raw(1.0, FlowType::Fixed, Some(f64::NAN));
         assert!(invalid.validate().is_err());
-        let invalid = create_process_flow_raw(1.0, FlowType::Fixed, Some(f64::NEG_INFINITY), true);
+        let invalid = create_process_flow_raw(1.0, FlowType::Fixed, Some(f64::NEG_INFINITY));
         assert!(invalid.validate().is_err());
-        let invalid = create_process_flow_raw(1.0, FlowType::Fixed, Some(f64::INFINITY), true);
+        let invalid = create_process_flow_raw(1.0, FlowType::Fixed, Some(f64::INFINITY));
         assert!(invalid.validate().is_err());
     }
 
-    fn create_process_flow(commodity: Rc<Commodity>, coeff: f64, is_pac: bool) -> ProcessFlow {
-        ProcessFlow {
-            commodity,
-            coeff,
-            kind: FlowType::Fixed,
-            cost: 0.0,
-            is_pac,
-        }
-    }
-
     #[fixture]
     fn commodity1() -> Commodity {
         Commodity {
@@ -278,44 +223,4 @@ mod tests {
             levies: CommodityLevyMap::default(),
         }
     }
-
-    #[rstest]
-    fn test_validate_flow_map_valid_single(commodity1: Commodity, commodity2: Commodity) {
-        // Valid: Single PAC
-        let flows = indexmap! {
-            commodity1.id.clone() => create_process_flow(commodity1.into(), 1.0, true),
-            commodity2.id.clone() => create_process_flow(commodity2.into(), 1.0, false),
-        };
-        assert!(validate_flow_map(&flows).is_ok());
-    }
-
-    #[rstest]
-    fn test_validate_flow_map_valid_multiple(commodity1: Commodity, commodity2: Commodity) {
-        // Valid: Multiple PACs
-        let flows = indexmap! {
-            commodity1.id.clone() => create_process_flow(commodity1.into(), 1.0, true),
-            commodity2.id.clone() => create_process_flow(commodity2.into(), 1.0, true),
-        };
-        assert!(validate_flow_map(&flows).is_ok());
-    }
-
-    #[rstest]
-    fn test_validate_flow_map_invalid_no_pacs(commodity1: Commodity, commodity2: Commodity) {
-        // Invalid: No PACs
-        let flows = indexmap! {
-            commodity1.id.clone() => create_process_flow(commodity1.into(), 1.0, false),
-            commodity2.id.clone() => create_process_flow(commodity2.into(), 1.0, false),
-        };
-        assert!(validate_flow_map(&flows).is_err());
-    }
-
-    #[rstest]
-    fn test_validate_flow_map(commodity1: Commodity, commodity2: Commodity) {
-        // Invalid: Mixed PAC flow types
-        let flows = indexmap! {
-            commodity1.id.clone() => create_process_flow(commodity1.into(), 1.0, true),
-            commodity2.id.clone() => create_process_flow(commodity2.into(), -1.0, true),
-        };
-        assert!(validate_flow_map(&flows).is_err());
-    }
 }