rustpower 0.4.1

An experimental ECS world snapshot system built on Bevy, featuring structured archetype storage and manifest-based serialization.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

#![allow(deprecated)]
use std::{env, time::Instant};

use bevy_archive::prelude::{load_world_manifest, read_manifest_from_file};
use ecs::post_processing::PostProcessing;
use rustpower::{
    io::archive::aurora_format::ArchiveSnapshotRes,
    prelude::*,
    timeseries::{
        TimeSeriesDefaultPlugins,
        scheduled::{ScheduledStaticAction, ScheduledStaticActions},
        sim_time::{DeltaTime, Time},
        state::TimeSeriesData,
    },
};

#[macro_export]
macro_rules! timeit {
    ($name:ident, $times:expr, $block:expr) => {{
        use std::time::{Duration, Instant};
        let mut total_duration = Duration::new(0, 0);
        let mut max_duration = Duration::new(0, 0);
        let mut min_duration = Duration::new(u64::MAX, 999_999_999);

        for _ in 0..$times {
            let start_time = Instant::now();
            let _result = $block();
            let end_time = Instant::now();
            let duration = end_time - start_time;

            total_duration += duration;
            if duration > max_duration {
                max_duration = duration;
            }
            if duration < min_duration {
                min_duration = duration;
            }
        }

        let avg_duration = total_duration / $times;
        println!(
            " {} loops, {} - Average: {:?}, Max: {:?}, Min: {:?}",
            $times,
            stringify!($name),
            avg_duration,
            max_duration,
            min_duration
        );
    }};
}

fn main() {
    let dir = env::var("CARGO_MANIFEST_DIR").unwrap();
    let file = format!("{}/cases/pegase9241/time_series.toml", dir);

    // Initialize the default ECS application with predefined plugins
    let mut pf_net = default_app();
    pf_net.add_plugins(TimeSeriesDefaultPlugins);
    pf_net.insert_resource(DeltaTime(15.0 * 60.0));
    pf_net.insert_resource(TimeSeriesData::default());
    pf_net.world_mut().spawn(ScheduledStaticActions {
        queue: vec![
            ScheduledStaticAction {
                execute_at: 30.0 * 60.0,
                action: rustpower::timeseries::scheduled::ScheduledActionKind::SetTargetPMW {
                    bus: 0,
                    value: 1000.0,
                },
            },
            ScheduledStaticAction {
                execute_at: 120.0 * 60.0,
                action: rustpower::timeseries::scheduled::ScheduledActionKind::SetTargetPMW {
                    bus: 9235,
                    value: 209.0,
                },
            },
        ]
        .into(),
    });
    let net = read_manifest_from_file(&file, None).unwrap();
    // Initialize the default ECS application with predefined plugins

    // pf_net.add_plugins(QLimPlugin);
    pf_net
        .world_mut()
        .resource_scope::<ArchiveSnapshotRes, _>(|world, registry| {
            load_world_manifest(world, &net, &registry.0.case_file_reg).unwrap();
        });
    // let archive = pf_net.to_case_file().unwrap();
    // archive.to_file("data_before.toml", None).unwrap();
    let t_end = 24.0 * 60.0 * 60.0;
    let tstart = Instant::now();
    while pf_net.world().resource::<Time>().0 < t_end {
        pf_net.update();
        //this will initalize the data for pf in the first run
        // Extract and validate the results
        // let results = pf_net.world().get_resource::<PowerFlowResult>().unwrap();
        // assert_eq!(results.converged, true);
        // println!("ECS APP converged within {} iterations", results.iterations);
    }
    let dur = Instant::now() - tstart;
    println!("ECS APP took {} ms", dur.as_millis());
    // Post-process and print the results
    pf_net.post_process();
    pf_net.print_res_bus();

    timeit!(pegase9241, 10, || pf_net.update());
}