Add allow_unspecified_inverters config option

When true, inverters with `InverterType::Unspecified` are treated as
having `InverterType::Battery`.

This commit also adds "tracing" as a dependency and logs warnings when
inverters with unspecified type are encountered.

Signed-off-by: Sahas Subramanian <sahas.subramanian@proton.me>

Author: shsms

Cargo.toml

@@ -9,3 +9,4 @@ path = "src/lib.rs"
 
 [dependencies]
 petgraph = "0.6.5"
+tracing = "0.1.40"

src/component_category.rs

@@ -5,6 +5,7 @@
 //! category of a component.
 
 use crate::graph_traits::Node;
+use crate::ComponentGraphConfig;
 use std::fmt::Display;
 
 /// Represents the type of an inverter.
@@ -135,8 +136,14 @@ pub(crate) trait CategoryPredicates: Node {
         matches!(self.category(), ComponentCategory::Inverter(_))
     }
 
-    fn is_battery_inverter(&self) -> bool {
-        self.category() == ComponentCategory::Inverter(InverterType::Battery)
+    fn is_battery_inverter(&self, config: &ComponentGraphConfig) -> bool {
+        match self.category() {
+            ComponentCategory::Inverter(InverterType::Battery) => true,
+            ComponentCategory::Inverter(InverterType::Unspecified) => {
+                config.allow_unspecified_inverters
+            }
+            _ => false,
+        }
     }
 
     fn is_pv_inverter(&self) -> bool {
@@ -147,8 +154,13 @@ pub(crate) trait CategoryPredicates: Node {
         self.category() == ComponentCategory::Inverter(InverterType::Hybrid)
     }
 
-    fn is_unspecified_inverter(&self) -> bool {
-        self.category() == ComponentCategory::Inverter(InverterType::Unspecified)
+    fn is_unspecified_inverter(&self, config: &ComponentGraphConfig) -> bool {
+        match self.category() {
+            ComponentCategory::Inverter(InverterType::Unspecified) => {
+                !config.allow_unspecified_inverters
+            }
+            _ => false,
+        }
     }
 
     fn is_ev_charger(&self) -> bool {

src/config.rs

@@ -5,4 +5,9 @@
 
 /// Configuration options for the `ComponentGraph`.
 #[derive(Clone, Default, Debug)]
-pub struct ComponentGraphConfig {}
+pub struct ComponentGraphConfig {
+    /// Whether to allow untyped inverters in the graph.  When this is `true`,
+    /// inverters that have `InverterType::Unspecified` will be assumed to be
+    /// Battery inverters.
+    pub allow_unspecified_inverters: bool,
+}

src/graph/creation.rs

@@ -71,7 +71,7 @@ where
                     "ComponentCategory not specified for component: {cid}"
                 )));
             }
-            if component.is_unspecified_inverter() {
+            if component.is_unspecified_inverter(config) {
                 return Err(Error::invalid_component(format!(
                     "InverterType not specified for inverter: {cid}"
                 )));
@@ -163,12 +163,24 @@ mod tests {
                 == Error::invalid_component("ComponentCategory not specified for component: 8")));
 
         builder.pop_component();
-        builder.add_component(ComponentCategory::Inverter(InverterType::Unspecified));
+        let unspec_inv =
+            builder.add_component(ComponentCategory::Inverter(InverterType::Unspecified));
+        builder.connect(grid_meter, unspec_inv);
+
+        // With default config, unspecified inverter types are not accepted.
         assert!(builder.build(None).is_err_and(
             |e| e == Error::invalid_component("InverterType not specified for inverter: 9")
         ));
+        // With `allow_unspecified_inverters=true`, unspecified inverter types
+        // are treated as battery inverters.
+        assert!(builder
+            .build(Some(ComponentGraphConfig {
+                allow_unspecified_inverters: true
+            }))
+            .is_ok());
 
         builder.pop_component();
+        builder.pop_connection();
         builder.add_component(ComponentCategory::Grid);
         assert!(builder
             .build(None)

src/graph/formulas/fallback.rs

@@ -120,7 +120,7 @@ where
         component_id: u64,
     ) -> Result<Option<Expr>, Error> {
         let component = self.graph.component(component_id)?;
-        if !component.is_battery_inverter()
+        if !component.is_battery_inverter(&self.graph.config)
             && !component.is_chp()
             && !component.is_pv_inverter()
             && !component.is_ev_charger()

src/graph/formulas/generators/battery.rs

@@ -31,7 +31,7 @@ where
         } else {
             graph.find_all(
                 graph.root_id,
-                |node| node.is_battery_inverter(),
+                |node| node.is_battery_inverter(&graph.config),
                 petgraph::Direction::Outgoing,
                 false,
             )?
@@ -91,7 +91,9 @@ where
 mod tests {
     use std::collections::BTreeSet;
 
-    use crate::{graph::test_utils::ComponentGraphBuilder, Error};
+    use crate::{
+        graph::test_utils::ComponentGraphBuilder, ComponentGraphConfig, Error, InverterType,
+    };
 
     #[test]
     fn test_battery_formula() -> Result<(), Error> {
@@ -188,12 +190,23 @@ mod tests {
         assert_eq!(meter.component_id(), 17);
         assert_eq!(inv_bat_chain.component_id(), 18);
 
-        let inv_bat_chain = builder.inv_bat_chain(1);
-        builder.connect(meter, inv_bat_chain);
+        let unspec_inverter = builder.add_component(crate::ComponentCategory::Inverter(
+            InverterType::Unspecified,
+        ));
+        let battery = builder.battery();
+        builder.connect(unspec_inverter, battery);
+        builder.connect(meter, unspec_inverter);
 
-        assert_eq!(inv_bat_chain.component_id(), 20);
+        assert_eq!(unspec_inverter.component_id(), 20);
 
-        let graph = builder.build(None)?;
+        assert!(builder
+            .build(None)
+            .is_err_and(|x| x.to_string()
+                == "InvalidComponent: InverterType not specified for inverter: 20"));
+
+        let graph = builder.build(Some(ComponentGraphConfig {
+            allow_unspecified_inverters: true,
+        }))?;
         let formula = graph.battery_formula(None)?;
         assert_eq!(
             formula,

src/graph/formulas/generators/consumer.rs

@@ -49,7 +49,7 @@ where
         let other_grid_successors = self
             .graph
             .successors(self.graph.root_id)?
-            .filter(|s| !s.is_meter() && !s.is_battery_inverter())
+            .filter(|s| !s.is_meter() && !s.is_battery_inverter(&self.graph.config))
             .map(|s| self.component_consumption(s.component_id()))
             .reduce(|a, b| Ok(a? + b?));
 

src/graph/meter_roles.rs

@@ -36,7 +36,7 @@ where
         Ok(self.component(component_id)?.is_meter()
             && self.successors(component_id)?.all(|n| {
                 has_successors = true;
-                n.is_battery_inverter()
+                n.is_battery_inverter(&self.config)
             })
             && has_successors)
     }

src/graph/validation/validate_neighbors.rs

@@ -79,10 +79,20 @@ where
                     self.ensure_on_successors(inverter, |n| n.is_battery(), "Batteries")?;
                 }
                 InverterType::Unspecified => {
-                    return Err(Error::invalid_graph(format!(
-                        "Inverter {} has an unspecified inverter type.",
-                        inverter.component_id()
-                    )));
+                    if !self.cg.config.allow_unspecified_inverters {
+                        return Err(Error::invalid_graph(format!(
+                            "Inverter {} has an unspecified inverter type.",
+                            inverter.component_id()
+                        )));
+                    } else {
+                        tracing::warn!(
+                            concat!(
+                                "Inverter {} has an unspecified inverter type will be ",
+                                "considered a Battery Inverter."
+                            ),
+                            inverter.component_id()
+                        );
+                    }
                 }
             }
         }
@@ -98,7 +108,7 @@ where
             self.ensure_leaf(battery)?;
             self.ensure_on_predecessors(
                 battery,
-                |n| n.is_battery_inverter() || n.is_hybrid_inverter(),
+                |n| n.is_battery_inverter(&self.cg.config) || n.is_hybrid_inverter(),
                 "BatteryInverters or HybridInverters",
             )?;
         }