Struct DcBatchSolver 

pub struct DcBatchSolver { /* private fields */ }

Solves many DC scenarios over one shared topology.

let scenarios: Vec<Scenario> = (0..10_000)
    .map(|k| Scenario::new(vec![BusOverride::new(3).p(-0.1 * k as f64)]))
    .collect();
let batch = DcBatchSolver::new();
let results = batch
    .solve(&buses, &lines, &transformers, DcOptions::default(), &scenarios)
    .unwrap();
assert_eq!(results.len(), 10_000);

Implementations

impl DcBatchSolver

pub fn new() -> Self

Uses rayon’s global thread pool (honors RAYON_NUM_THREADS).

pub fn with_threads(threads: usize) -> Result<Self, BatchError>

Uses a dedicated pool of exactly threads workers, built once here and reused by every solve call.

pub fn threads(&self) -> usize

pub fn solve( &self, buses_template: &[Bus], lines: &[Line], transformers: &[Transformer], opts: DcOptions, scenarios: &[Scenario], ) -> Result<Vec<DcBatchResult>, BatchError>

Solves every scenario, returning one DcBatchResult each in scenario order regardless of thread count.

Each scenario starts from buses_template with its own overrides applied, so scenarios never influence one another. BusOverride::voltage_mag is ignored: DC has no magnitude state to set. BusOverride::q_spec is ignored too, for the same reason.

Errors only for input that cannot be interpreted — an out-of-range bus, a branch outage, or a network whose reduced B is singular. A scenario cannot “fail to converge”, since nothing iterates.

pub fn islands( buses_template: &[Bus], lines: &[Line], transformers: &[Transformer], opts: DcOptions, ) -> Vec<DcIslandReport>

The base solve’s per-island breakdown, in the order DcBatchResult::slack_pickup indexes.

Computed from the template, so it is the same for every scenario — island membership depends on topology, which a bus override cannot change.

Trait Implementations

impl Default for DcBatchSolver

fn default() -> Self

Returns the “default value” for a type.