frequenz-microgrid-component-graph 0.5.0

A library for representing the components of a microgrid and the connections between them as a Directed Acyclic Graph (DAG).
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

// License: MIT
// Copyright © 2024 Frequenz Energy-as-a-Service GmbH

//! Methods for validating a [`ComponentGraph`].

mod invariant_checks;
mod validate_graph;
mod validate_neighbors;

use crate::{ComponentGraph, Edge, Error, Node};

pub(crate) struct ComponentGraphValidator<'a, N, E>
where
    N: Node,
    E: Edge,
{
    cg: &'a ComponentGraph<N, E>,
    root: &'a N,
}

impl<N, E> ComponentGraph<N, E>
where
    N: Node,
    E: Edge,
{
    pub(crate) fn validate(&self) -> Result<(), Error> {
        let Ok(root) = self.component(self.root_id) else {
            return Err(Error::internal(format!(
                "Grid component not found with detected component ID: {}.",
                self.root_id
            )));
        };

        let validator = ComponentGraphValidator { cg: self, root };

        // Fail immediately if there are cycles in the graph, as this may cause
        // subsequent validations to get stuck in an infinite loop.
        validator.validate_acyclicity(root, vec![])?;

        let mut errors = vec![];
        let mut validation_failed = false;

        if let Err(err) = validator.validate_connected_graph(root) {
            errors.push(err);
            validation_failed = !self.config.allow_unconnected_components;
        }

        for result in [
            validator.validate_root(),
            validator.validate_meters(),
            validator.validate_inverters(),
            validator.validate_batteries(),
            validator.validate_ev_chargers(),
            validator.validate_chps(),
            validator.validate_steam_boilers(),
        ] {
            if let Err(e) = result {
                errors.push(e);
                validation_failed = !self.config.allow_component_validation_failures;
            }
        }
        match errors.len() {
            0 => {}
            1 => {
                if validation_failed {
                    return Err(errors[0].clone());
                } else {
                    tracing::warn!("{}", errors[0]);
                }
            }
            _ => {
                let err = Error::invalid_graph(format!(
                    "Multiple validation failures:\n    {}",
                    errors
                        .iter()
                        .map(ToString::to_string)
                        .collect::<Vec<_>>()
                        .join("\n    ")
                ));
                if validation_failed {
                    return Err(err);
                } else {
                    tracing::warn!("{}", err);
                }
            }
        }
        Ok(())
    }
}