1use std::collections::HashSet;
4
5use powerio_prob::{ConstraintSelection, Objective, ObjectiveTerm, ReferenceBuses};
6use powerio_tx::{BalancedNetwork, BusId, BusType, IndexedNetwork};
7
8use crate::{Error, Result};
9
10#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
12#[serde(rename_all = "snake_case")]
13#[non_exhaustive]
14pub enum PreparedObjective {
15 Feasibility,
17 #[default]
19 NetworkGeneratorCost,
20}
21
22#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
30#[non_exhaustive]
31pub struct PiecewiseLinearCost {
32 pub power: Vec<f64>,
34 pub value: Vec<f64>,
36}
37
38#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
46#[serde(rename_all = "snake_case", tag = "kind")]
47#[non_exhaustive]
48pub enum AnalysisBranchSource {
49 Branch {
50 row: usize,
51 },
52 ThreeWindingTransformerWinding {
53 transformer_row: usize,
54 winding: usize,
56 },
57}
58
59pub(crate) fn analysis_branch_sources(source: &BalancedNetwork) -> Vec<AnalysisBranchSource> {
60 let mut sources = (0..source.branches().len())
61 .map(|row| AnalysisBranchSource::Branch { row })
62 .collect::<Vec<_>>();
63 for (transformer_row, transformer) in source.transformers_3w().iter().enumerate() {
64 if !transformer.in_service {
65 continue;
66 }
67 sources.extend((0..3).map(|winding| {
68 AnalysisBranchSource::ThreeWindingTransformerWinding {
69 transformer_row,
70 winding,
71 }
72 }));
73 }
74 sources
75}
76
77pub(crate) fn compile_objective(objective: &Objective) -> Result<PreparedObjective> {
78 match objective.terms() {
79 [] => Ok(PreparedObjective::Feasibility),
80 [ObjectiveTerm::NetworkGeneratorCost] => Ok(PreparedObjective::NetworkGeneratorCost),
81 [ObjectiveTerm::ActivePowerDispatchCost] => Err(Error::UnsupportedOpfObjective {
82 reason: "`active_power_dispatch_cost` belongs to multiconductor OPF".to_owned(),
83 }),
84 _ => Err(Error::UnsupportedOpfObjective {
85 reason: "balanced OPF preparation supports either an empty objective or exactly one `network_generator_cost` term".to_owned(),
86 }),
87 }
88}
89
90pub(crate) fn row_identity(uid: Option<&str>, table: &str, row: usize) -> String {
91 uid.map_or_else(|| format!("{table}:{row}"), str::to_owned)
92}
93
94pub(crate) struct ActiveBusIndex {
98 pub analysis_rows: Vec<usize>,
99 pub dense_by_analysis: Vec<Option<usize>>,
100 pub bus_ids: Vec<BusId>,
101 pub reference_buses: ReferenceBuses,
102}
103
104pub(crate) fn active_bus_index(case: &IndexedNetwork<'_>) -> Result<ActiveBusIndex> {
108 let mut analysis_rows = Vec::new();
109 let mut dense_by_analysis = vec![None; case.n()];
110 let mut bus_ids = Vec::new();
111 let mut reference_rows = Vec::new();
112 for (analysis_row, bus) in case.network().buses().iter().enumerate() {
113 if bus.kind == BusType::Isolated {
114 continue;
115 }
116 let dense = analysis_rows.len();
117 analysis_rows.push(analysis_row);
118 dense_by_analysis[analysis_row] = Some(dense);
119 bus_ids.push(bus.id);
120 if bus.kind == BusType::Ref {
121 reference_rows.push(dense);
122 }
123 }
124
125 let (from_bus, to_bus): (Vec<usize>, Vec<usize>) = case
128 .in_service_branches()
129 .filter_map(|(_, branch)| {
130 let from = dense_by_analysis[case.bus_index(branch.from)?]?;
131 let to = dense_by_analysis[case.bus_index(branch.to)?]?;
132 Some((from, to))
133 })
134 .unzip();
135 let labels = powerio_tx::calc_dense_island_labels(analysis_rows.len(), &from_bus, &to_bus);
136 let islands = labels.iter().max().map_or(0, |&last| last + 1);
137 let mut grounded = vec![false; islands];
138 for &reference in &reference_rows {
139 grounded[labels[reference]] = true;
140 }
141 let ungrounded = grounded.iter().filter(|&&grounded| !grounded).count();
142 if ungrounded > 0 {
143 return Err(powerio_tx::Error::UngroundedComponent {
144 components: ungrounded,
145 }
146 .into());
147 }
148
149 Ok(ActiveBusIndex {
150 analysis_rows,
151 dense_by_analysis,
152 bus_ids,
153 reference_buses: ReferenceBuses::new(reference_rows),
154 })
155}
156
157pub(crate) fn constraint_mask(
160 family: &'static str,
161 selection: &ConstraintSelection,
162 all_identities: &[String],
163 active_identities: &[String],
164) -> Result<Vec<bool>> {
165 let mut declared = HashSet::with_capacity(all_identities.len());
166 for identity in all_identities {
167 if !declared.insert(identity.as_str()) {
168 return Err(Error::DuplicateElementIdentity {
169 family,
170 identity: identity.clone(),
171 });
172 }
173 }
174 let ConstraintSelection::Only(selected) = selection else {
175 return Ok(active_identities
176 .iter()
177 .map(|identity| selection.selects(identity))
178 .collect());
179 };
180 for identity in selected {
181 if !declared.contains(identity.as_str()) {
182 return Err(Error::UnknownConstraintIdentity {
183 family,
184 identity: identity.clone(),
185 });
186 }
187 }
188 let selected: HashSet<&str> = selected.iter().map(String::as_str).collect();
191 Ok(active_identities
192 .iter()
193 .map(|identity| selected.contains(identity.as_str()))
194 .collect())
195}
196
197pub(crate) mod nonfinite_vec {
200 use powerio_core::__implementation::nonfinite::{NonFiniteDe, NonFiniteSer};
201 use serde::{Deserialize, Deserializer, Serialize, Serializer};
202
203 pub fn serialize<S: Serializer>(values: &[f64], serializer: S) -> Result<S::Ok, S::Error> {
204 values.serialize(NonFiniteSer(serializer))
205 }
206
207 pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<f64>, D::Error> {
208 Vec::<f64>::deserialize(NonFiniteDe(deserializer))
209 }
210}