Inverse groups seem to work (somehow)

examples/group_reverse_example.rs

@@ -6,9 +6,10 @@ use opossum::{
     lightdata::{DataEnergy, LightData},
     nodes::{Detector, Dummy, NodeGroup, Source},
     optic_node::OpticNode,
-    spectrum::create_he_ne_spectrum,
+    spectrum::{create_he_ne_spectrum, Spectrum},
     OpticScenery, analyzer::AnalyzerEnergy,
 };
+use uom::si::length::{Length, nanometer};
 
 fn main() -> Result<(), OpossumError> {
     let mut scenery = OpticScenery::new();
@@ -21,10 +22,19 @@ fn main() -> Result<(), OpossumError> {
         })),
     );
 
+    // let i_s = scenery.add_element(
+    //     "Source",
+    //     Source::new(LightData::Energy(DataEnergy {
+    //         spectrum: Spectrum::new(
+    //             Length::new::<nanometer>(500.0)..Length::new::<nanometer>(503.0),
+    //             Length::new::<nanometer>(1.0)).unwrap()}),
+    //     ),
+    // );
+
     let mut group = NodeGroup::new();
     group.expand_view(true);
-    let g_n1 = group.add_node(OpticNode::new("A", Dummy));
-    let g_n2 = group.add_node(OpticNode::new("B", Dummy));
+    let g_n1 = group.add_node(OpticNode::new("A", Dummy::default()));
+    let g_n2 = group.add_node(OpticNode::new("B", Dummy::default()));
 
     group.connect_nodes(g_n1, "rear", g_n2, "front")?;
     group.map_input_port(g_n1, "front", "in1")?;

src/nodes/dummy.rs

@@ -7,7 +7,7 @@ use crate::optic_ports::OpticPorts;
 
 type Result<T> = std::result::Result<T, OpossumError>;
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 /// A fake / dummy component without any optical functionality.
 ///
 /// Any [`LightResult`] is directly forwarded without any modification. It is mainly used for
@@ -18,7 +18,9 @@ type Result<T> = std::result::Result<T, OpossumError>;
 ///     - `front`
 ///   - Outputs
 ///     - `rear`
-pub struct Dummy;
+pub struct Dummy {
+    is_inverted: bool,
+}
 
 impl Optical for Dummy {
     /// Returns "dummy" as node type.
@@ -37,12 +39,23 @@ impl Optical for Dummy {
         incoming_data: LightResult,
         _analyzer_type: &AnalyzerType,
     ) -> Result<LightResult> {
-        if let Some(data) = incoming_data.get("front") {
-            Ok(HashMap::from([("rear".into(), data.clone())]))
+        if !self.is_inverted {
+            if let Some(data) = incoming_data.get("front") {
+                Ok(HashMap::from([("rear".into(), data.clone())]))
+            } else {
+                Ok(HashMap::from([("rear".into(), None)]))
+            }
         } else {
-            Ok(HashMap::from([("rear".into(), None)]))
+            if let Some(data) = incoming_data.get("rear") {
+                Ok(HashMap::from([("front".into(), data.clone())]))
+            } else {
+                Ok(HashMap::from([("front".into(), None)]))
+            }
         }
     }
+    fn set_inverted(&mut self, inverted: bool) {
+        self.is_inverted=true;
+    }
 }
 
 impl Dottable for Dummy {}

src/nodes/group.rs

@@ -349,14 +349,15 @@ impl NodeGroup {
                 self.incoming_edges(idx)
             };
             let node = self.g.node_weight(idx).unwrap();
-            println!("Analyzing node {}", node.borrow().name());
-            println!("Incoming edges {:?}", incoming_edges);
+            // println!("Analyzing node {}", node.borrow().name());
+            // println!("Incoming edges {:?}", incoming_edges);
             let outgoing_edges = node.borrow_mut().analyze(incoming_edges, analyzer_type)?;
-            println!("Outgoing edges: {:?}", outgoing_edges);
+            // println!("Outgoing edges: {:?}", outgoing_edges);
             let mut group_sinks = self.g.externals(Direction::Outgoing);
             // Check if node is group sink node
             if group_sinks.any(|gs| gs == idx) {
-                let assigned_ports = self.output_port_map.iter().filter(|p| p.1 .0 == idx);
+                let portmap = if self.is_inverted { &self.input_port_map} else { &self.output_port_map};
+                let assigned_ports = portmap.iter().filter(|p| p.1 .0 == idx);
                 for port in assigned_ports {
                     light_result.insert(
                         port.0.to_owned(),
@@ -659,16 +660,16 @@ mod test {
     #[test]
     fn add_node() {
         let mut og = NodeGroup::new();
-        let sub_node = OpticNode::new("test", Dummy);
+        let sub_node = OpticNode::new("test", Dummy::default());
         og.add_node(sub_node);
         assert_eq!(og.g.node_count(), 1);
     }
     #[test]
     fn connect_nodes() {
         let mut og = NodeGroup::new();
-        let sub_node1 = OpticNode::new("test1", Dummy);
+        let sub_node1 = OpticNode::new("test1", Dummy::default());
         let sn1_i = og.add_node(sub_node1);
-        let sub_node2 = OpticNode::new("test2", Dummy);
+        let sub_node2 = OpticNode::new("test2", Dummy::default());
         let sn2_i = og.add_node(sub_node2);
         // wrong port names
         assert!(og.connect_nodes(sn1_i, "wrong", sn2_i, "front").is_err());
@@ -687,9 +688,9 @@ mod test {
     #[test]
     fn connect_nodes_update_port_mapping() {
         let mut og = NodeGroup::new();
-        let sub_node1 = OpticNode::new("test1", Dummy);
+        let sub_node1 = OpticNode::new("test1", Dummy::default());
         let sn1_i = og.add_node(sub_node1);
-        let sub_node2 = OpticNode::new("test2", Dummy);
+        let sub_node2 = OpticNode::new("test2", Dummy::default());
         let sn2_i = og.add_node(sub_node2);
 
         og.map_input_port(sn2_i, "front", "input").unwrap();
@@ -704,9 +705,9 @@ mod test {
     #[test]
     fn input_nodes() {
         let mut og = NodeGroup::new();
-        let sub_node1 = OpticNode::new("test1", Dummy);
+        let sub_node1 = OpticNode::new("test1", Dummy::default());
         let sn1_i = og.add_node(sub_node1);
-        let sub_node1 = OpticNode::new("test2", Dummy);
+        let sub_node1 = OpticNode::new("test2", Dummy::default());
         let sn2_i = og.add_node(sub_node1);
         let sub_node3 = OpticNode::new("test3", BeamSplitter::new(0.5));
         let sn3_i = og.add_node(sub_node3);
@@ -717,11 +718,11 @@ mod test {
     #[test]
     fn output_nodes() {
         let mut og = NodeGroup::new();
-        let sub_node1 = OpticNode::new("test1", Dummy);
+        let sub_node1 = OpticNode::new("test1", Dummy::default());
         let sn1_i = og.add_node(sub_node1);
         let sub_node1 = OpticNode::new("test2", BeamSplitter::new(0.5));
         let sn2_i = og.add_node(sub_node1);
-        let sub_node3 = OpticNode::new("test3", Dummy);
+        let sub_node3 = OpticNode::new("test3", Dummy::default());
         let sn3_i = og.add_node(sub_node3);
         og.connect_nodes(sn1_i, "rear", sn2_i, "input1").unwrap();
         og.connect_nodes(sn2_i, "out1_trans1_refl2", sn3_i, "front")
@@ -731,9 +732,9 @@ mod test {
     #[test]
     fn map_input_port() {
         let mut og = NodeGroup::new();
-        let sub_node1 = OpticNode::new("test1", Dummy);
+        let sub_node1 = OpticNode::new("test1", Dummy::default());
         let sn1_i = og.add_node(sub_node1);
-        let sub_node2 = OpticNode::new("test2", Dummy);
+        let sub_node2 = OpticNode::new("test2", Dummy::default());
         let sn2_i = og.add_node(sub_node2);
         og.connect_nodes(sn1_i, "rear", sn2_i, "front").unwrap();
 
@@ -756,7 +757,7 @@ mod test {
     #[test]
     fn map_input_port_half_connected_nodes() {
         let mut og = NodeGroup::new();
-        let sub_node1 = OpticNode::new("test1", Dummy);
+        let sub_node1 = OpticNode::new("test1", Dummy::default());
         let sn1_i = og.add_node(sub_node1);
         let sub_node2 = OpticNode::new("test2", BeamSplitter::default());
         let sn2_i = og.add_node(sub_node2);
@@ -773,9 +774,9 @@ mod test {
     #[test]
     fn map_output_port() {
         let mut og = NodeGroup::new();
-        let sub_node1 = OpticNode::new("test1", Dummy);
+        let sub_node1 = OpticNode::new("test1", Dummy::default());
         let sn1_i = og.add_node(sub_node1);
-        let sub_node2 = OpticNode::new("test2", Dummy);
+        let sub_node2 = OpticNode::new("test2", Dummy::default());
         let sn2_i = og.add_node(sub_node2);
         og.connect_nodes(sn1_i, "rear", sn2_i, "front").unwrap();
 
@@ -800,7 +801,7 @@ mod test {
         let mut og = NodeGroup::new();
         let sub_node1 = OpticNode::new("test1", BeamSplitter::default());
         let sn1_i = og.add_node(sub_node1);
-        let sub_node2 = OpticNode::new("test2", Dummy);
+        let sub_node2 = OpticNode::new("test2", Dummy::default());
         let sn2_i = og.add_node(sub_node2);
         og.connect_nodes(sn1_i, "out1_trans1_refl2", sn2_i, "front")
             .unwrap();
@@ -820,9 +821,9 @@ mod test {
     #[test]
     fn ports() {
         let mut og = NodeGroup::new();
-        let sub_node1 = OpticNode::new("test1", Dummy);
+        let sub_node1 = OpticNode::new("test1", Dummy::default());
         let sn1_i = og.add_node(sub_node1);
-        let sub_node2 = OpticNode::new("test2", Dummy);
+        let sub_node2 = OpticNode::new("test2", Dummy::default());
         let sn2_i = og.add_node(sub_node2);
         og.connect_nodes(sn1_i, "rear", sn2_i, "front").unwrap();
         assert!(og.ports().inputs().is_empty());