EnerOS v0.38.0

Release Date: 2026-06-06 Codename: Sim Git Tag: v0.38.0 Support Status: Stable Total Crates: 96 (6 new) Test Cases: 12100+ (700 new)

Overview

EnerOS v0.38.0 “Sim” is a real-time simulation-focused release, integrating full-scenario power system simulation capabilities into the EnerOS kernel. This release enables EnerOS to directly run three types of simulation in the kernel: electromagnetic transient, electromechanical transient, and medium-to-long-term dynamics, covering the full time scale from microsecond-level power electronics switching dynamics to minute-level system-level dynamics.

The core design philosophy of the Sim release is “simulation as system call” — simulation is no longer a standalone external tool, but a kernel first-class citizen. Agents trigger simulation through system calls, and simulation results are fed directly back to the decision chain, achieving a closed loop of “simulation validation - decision - execution.” This enables any dispatching operation to complete second-level simulation pre-validation in the kernel before execution, shifting “trial and error” from physical space to digital space.

This release introduces five core capabilities: Electromagnetic Transient Simulation (EMTP), Electromechanical Transient Simulation, Medium-to-Long-term Dynamics Simulation, Simulation Acceleration Engine, and Simulation Scenario Management. All capabilities are implemented through five new crates: eneros-sim, eneros-sim-emt, eneros-sim-ts, eneros-sim-lt, and eneros-sim-accel.

Key Metrics

New Features

1. Electromagnetic Transient Simulation (EMT)

Adds the eneros-sim-emt crate, providing an electromagnetic transient simulation engine, supporting microsecond-level power electronic device switching dynamics, lightning overvoltage, switching overvoltage, and other fast electromagnetic transient processes.

EMT Simulation Configuration

use eneros_sim_emt::{EmtSimulator, EmtConfig, Solver};

let simulator = EmtSimulator::new(&network)
    .config(EmtConfig {
        time_step: Duration::microseconds(50),
        total_time: Duration::milliseconds(100),
        solver: Solver::Trapezoidal,
        interpolation: true,
        snubber_circuit: true,
    })
    .build().await?;

// Configure fault scenario
let fault = FaultScenario::new()
    .type(FaultType::ThreePhaseToGround)
    .location(BusId::from(5))
    .resistance(0.5)
    .onset(Duration::milliseconds(10))
    .duration(Duration::milliseconds(50));

simulator.apply_fault(fault)?;

// Run simulation
let result = simulator.run().await?;

// Extract results
let voltage = result.bus_voltage(BusId::from(5))?;
let current = result.branch_current(BranchId::from("L-3"))?;

println!("Max voltage during fault: {:.2} kV", voltage.max_abs() / 1000.0);
println!("Peak fault current: {:.2} kA", current.max_abs() / 1000.0);

EMT Component Models

Simulation Accuracy Validation

2. Electromechanical Transient Simulation

Adds the eneros-sim-ts crate, providing an electromechanical transient simulation engine, supporting system-level dynamic analysis such as transient stability analysis, rotor angle stability, voltage stability, and frequency stability.

Transient Stability Simulation

use eneros_sim_ts::{TransientSimulator, TsConfig};

let simulator = TransientSimulator::new(&network)
    .config(TsConfig {
        time_step: Duration::milliseconds(2),
        total_time: Duration::seconds(10),
        generator_model: GeneratorModel::Detailed {
            order: 6,  // 6th-order synchronous machine
            avr: true, // Excitation system
            governor: true, // Governor
            pss: true, // Power system stabilizer
        },
        load_model: LoadModel::Composite {
            static_ratio: 0.7,
            dynamic_ratio: 0.3,
        },
    })
    .build().await?;

// Simulate three-phase short circuit fault
let disturbance = Disturbance::three_phase_fault(BusId::from(8))
    .duration(Duration::milliseconds(80))
    .cleared_by_opening(BranchId::from("L-5"));

let result = simulator.run(disturbance).await?;

// Check transient stability
let stable = result.is_transient_stable()?;
println!("Transient stable: {}", if stable { "Yes" } else { "No" });

// Rotor angle curve
for gen in result.generators() {
    let max_angle = gen.max_rotor_angle();
    println!("Generator {} max rotor angle: {:.1} degrees", gen.id, max_angle.to_degrees());
}

Stability Analysis Capabilities

Critical Fault Clearing Time

// Calculate Critical Clearing Time (CCT)
let cct = simulator.critical_clearing_time(
    FaultType::ThreePhase,
    BusId::from(8),
).await?;

println!("Critical fault clearing time: {:.0} ms", cct.as_millis());
// Example output: Critical fault clearing time: 145 ms

3. Medium-to-Long-term Dynamics Simulation

Adds the eneros-sim-lt crate, providing a medium-to-long-term dynamics simulation engine, supporting minute-to-hour-level slow dynamic process analysis.

Long-term Dynamics Scenario

use eneros_sim_lt::{LongTermSimulator, LtConfig};

let simulator = LongTermSimulator::new(&network)
    .config(LtConfig {
        time_step: Duration::seconds(1),
        total_time: Duration::hours(2),
        models: LongTermModels {
            boiler_dynamics: true,     // Boiler slow dynamics
            load_frequency: true,      // Load frequency characteristics
            agc: true,                 // Automatic generation control
            oltc: true,                // On-load tap changer
            thermostat: true,          // Thermostatic load
        },
    })
    .build().await?;

// Simulate large-capacity renewable energy curtailment scenario
let scenario = LtScenario::new()
    .event(Event::generator_loss(BusId::from(1), 500.0).at("00:00:00"))
    .event(Event::renewable_curtailment(0.3).at("00:05:00"));

let result = simulator.run(scenario).await?;

// Frequency response analysis
let freq = result.system_frequency();
println!("Minimum frequency: {:.3} Hz", freq.min());
println!("Steady-state frequency: {:.3f} Hz", freq.steady_state());
println!("Recovery time: {:?}", freq.recovery_time());

Medium-to-Long-term Dynamics Components

4. Simulation Acceleration Engine

Adds the eneros-sim-accel crate, providing multi-level simulation acceleration capabilities, enabling large-scale simulations to complete within practical time scales.

Acceleration Technologies

Acceleration Configuration

use eneros_sim_accel::{Acceleration, AccelerationConfig};

let accel = Acceleration::new(AccelerationConfig {
    parallelism: Parallelism::MultiThread { threads: 8 },
    gpu: Some(GpuConfig {
        device: 0,
        batch_size: 1024,
    }),
    decoupling: Decoupling::Coefficient,
    cache: CacheStrategy::Adaptive,
});

// Apply accelerator to simulator
let simulator = EmtSimulator::new(&network)
    .acceleration(accel)
    .build().await?;

// 100ms simulation time, real-time ratio
let result = simulator.run().await?;
println!("Wall time: {:?}", result.wall_time);
println!("Simulated time: {:?}", result.simulated_time);
println!("Speedup: {:.1}x", result.speedup());

5. Simulation Scenario Management

Adds the eneros-sim crate (simulation core), providing unified simulation scenario management, batch simulation, and result comparison capabilities.

Batch Simulation

use eneros_sim::{SimulationManager, BatchScenario, SweepParam};

let manager = SimulationManager::new(&ctx);

// Parameter sweep: fault location × fault type
let batch = BatchScenario::new("N-1-analysis")
    .sweep(SweepParam::fault_location, vec![5, 8, 12, 15, 20])
    .sweep(SweepParam::fault_type, vec![FaultType::ThreePhase, FaultType::SinglePhase])
    .simulator(SimulatorType::Transient)
    .parallelism(8)
    .build();

let results = manager.run_batch(batch).await?;

// Summarize results
let summary = results.summary();
println!("Total {} scenarios:", summary.count);
println!("  Stable: {}", summary.stable_count);
println!("  Unstable: {}", summary.unstable_count);
println!("  Critical: {}", summary.critical_count);

// Identify worst-case scenario
let worst = results.worst_case();
println!("Worst-case scenario: {:?} @ Bus {}", worst.fault_type, worst.fault_bus);

Simulation Result Comparison

// Compare stability under different operation modes
let comparison = manager.compare(
    Scenario::from_mode(OperationMode::Normal),
    Scenario::from_mode(OperationMode::N_1),
    Scenario::from_mode(OperationMode::Maintenance),
).await?;

println!("{:<15} {:<10} {:<10} {:<10}", "Metric", "Normal", "N-1", "Maintenance");
for metric in &comparison.metrics {
    println!("{:<15} {:<10.2} {:<10.2} {:<10.2}",
        metric.name, metric.normal, metric.n1, metric.maintenance);
}

Simulation-Decision Closed Loop

// Auto-simulation pre-validation before dispatching
scheduler.on_before_dispatch(|schedule| {
    let scenario = Scenario::from_schedule(schedule);
    let result = manager.quick_check(scenario, Duration::seconds(5)).await?;

    if !result.is_stable() {
        // Simulation failed, reject dispatching plan
        return Err(RejectReason::Unstable(result.worst_violation));
    }
    Ok(())
}).await?;

Improvements

• Power Flow Calculation: Added PQ decomposition method and DC power flow, meeting different accuracy requirements
• Constraint Engine: Added dynamic security constraints, supporting simulation-driven constraint validation
• Timeseries Engine: Simulation results can be written directly to timeseries database for querying
• Agent Runtime: Simulation Agent supports priority scheduling, urgent simulations can preempt
• Observability: Simulation process supports full data recording and playback

Bug Fixes

• Fixed eneros-sim-emt numerical oscillation with large numbers of power electronic devices (#3803)
• Fixed eneros-sim-ts generator 6th-order model parameter loading error (#3810)
• Fixed eneros-sim-lt AGC model tie-line power calculation deviation between areas (#3816)
• Fixed eneros-sim-accel GPU acceleration inconsistent results in double-precision scenarios (#3822)
• Fixed eneros-sim batch simulation not releasing resources when cancelled midway (#3828)

Breaking Changes

• EmtSimulator::new: Parameter changed from &str to &NetworkGraph
• TransientSimulator::run: Parameter changed from () to Disturbance
• SimulationManager: All methods changed to async

Upgrade Guide

1. Update the eneros dependency in Cargo.toml to 0.38.0
2. Run eneros sim init to initialize the simulation engine
3. Configure simulation parameters and acceleration strategy in eneros.toml
4. Run eneros sim validate to validate model parameters

Acknowledgments

Thanks to the 38 contributors who submitted 580+ commits, and to power system simulation experts for model validation.