Struct SimulationOutput 

pub struct SimulationOutput {
    pub n_scenarios: u32,
    pub completed: u32,
    pub failed: u32,
    pub total_time_ms: u64,
    pub partitions_written: Vec<String>,
    pub cost: Option<MetadataCost>,
    pub solve_stats: MetadataSimulationSolveStats,
}

Aggregate type carrying simulation completion data for output writing.

Constructed by the simulation pipeline after it completes and optionally passed to write_results. When None is supplied, the simulation output directory is still created (ready for future use), but no simulation artifacts are written.

Fields

n_scenarios: u32

Total number of scenarios dispatched for simulation.

completed: u32

Number of scenarios that completed without error.

failed: u32

Number of scenarios that failed during simulation.

total_time_ms: u64

Total elapsed wall-clock time for the simulation run (ms).

partitions_written: Vec<String>

Hive partition paths written by the simulation writer.

Each element is a relative path string such as "simulation/costs/year=2030/month=01/part-00.parquet".

cost: Option<MetadataCost>

Aggregate cost statistics for the simulated scenarios.

None until a producer supplies it. When several per-rank outputs are combined via merge, the first present value wins; the producer is responsible for supplying the authoritative aggregate (which the distributed pipeline computes on rank 0) first.

solve_stats: MetadataSimulationSolveStats

Aggregate solve statistics for the simulation run.

Default-constructed (all fields None) by producers that do not yet record solve statistics; populated downstream and persisted into simulation/metadata.json by the metadata writer.

Implementations

impl SimulationOutput

pub fn merge(outputs: &[Self]) -> Self

Combine multiple per-rank simulation outputs into a single aggregate.

Merge rules:

• n_scenarios: sum across all outputs.
• completed: sum across all outputs.
• failed: sum across all outputs.
• total_time_ms: max across all outputs (wall-clock = slowest rank).
• partitions_written: concatenation of all outputs’ partitions, sorted for deterministic ordering regardless of input order.
• cost: first present value in slice order. The producer must supply the authoritative aggregate first (the distributed pipeline computes it on rank 0), so the merged cost is the rank-0 aggregate rather than a per-rank partial. None only when no input carried a cost.
• solve_stats: each count field is summed treating None as 0, with the result Some when any input recorded it (and None only when no input did); solve_seconds is summed with the same convention; parallelism takes the maximum across inputs (None-safe). Sums and max are order-invariant, so the merge is declaration-order invariant.

Returns a zeroed SimulationOutput (no cost, default solve stats) with empty partitions when the input slice is empty.

Trait Implementations

impl Clone for SimulationOutput

fn clone(&self) -> SimulationOutput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SimulationOutput

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

Formats the value using the given formatter.