Replace set with ordered list + shadow set for blocks, connections, events

milanofthe · milanofthe · commit 93c065cdfefa · 2026-03-17T09:13:55.000+01:00
diff --git a/src/pathsim/simulation.py b/src/pathsim/simulation.py
@@ -153,10 +153,10 @@ class Simulation:
         get attributes and access to intermediate evaluation stages
     logger : logging.Logger
         global simulation logger
-    _blocks_dyn : set[Block]
-        blocks with internal ´Solver´ instances (stateful) 
-    _blocks_evt : set[Block]
-        blocks with internal events (discrete time, eventful) 
+    _blocks_dyn : list[Block]
+        blocks with internal ´Solver´ instances (stateful)
+    _blocks_evt : list[Block]
+        blocks with internal events (discrete time, eventful)
     _active : bool
         flag for setting the simulation as active, used for interrupts
     """
@@ -176,10 +176,13 @@ def __init__(
         **solver_kwargs
         ):
 
-        #system definition
-        self.blocks      = set()
-        self.connections = set()
-        self.events      = set()
+        #system definition (ordered lists with shadow sets for O(1) lookup)
+        self.blocks      = []
+        self._block_set  = set()
+        self.connections = []
+        self._conn_set   = set()
+        self.events      = []
+        self._event_set  = set()
 
         #simulation timestep and bounds
         self.dt     = dt
@@ -215,10 +218,12 @@ def __init__(
         self.time = 0.0
 
         #collection of blocks with internal ODE solvers
-        self._blocks_dyn = set()
+        self._blocks_dyn = []
+        self._blocks_dyn_set = set()
 
         #collection of blocks with internal events
-        self._blocks_evt = set()
+        self._blocks_evt = []
+        self._blocks_evt_set = set()
 
         #flag for setting the simulation active
         self._active = True
@@ -269,9 +274,9 @@ def __contains__(self, other):
         bool
         """
         return (
-            other in self.blocks or 
-            other in self.connections or 
-            other in self.events
+            other in self._block_set or
+            other in self._conn_set or
+            other in self._event_set
             )
 
 
@@ -480,7 +485,7 @@ def add_block(self, block):
         """
 
         #check if block already in block list
-        if block in self.blocks:
+        if block in self._block_set:
             _msg = f"block {block} already part of simulation"
             self.logger.error(_msg)
             raise ValueError(_msg)
@@ -490,14 +495,17 @@ def add_block(self, block):
 
         #add to dynamic list if solver was initialized
         if block.engine:
-            self._blocks_dyn.add(block)
+            self._blocks_dyn.append(block)
+            self._blocks_dyn_set.add(block)
 
         #add to eventful list if internal events
         if block.events:
-            self._blocks_evt.add(block)
+            self._blocks_evt.append(block)
+            self._blocks_evt_set.add(block)
 
         #add block to global blocklist
-        self.blocks.add(block)
+        self.blocks.append(block)
+        self._block_set.add(block)
 
         #mark graph for rebuild
         if self.graph:
@@ -517,19 +525,24 @@ def remove_block(self, block):
         """
 
         #check if block is in block list
-        if block not in self.blocks:
+        if block not in self._block_set:
             _msg = f"block {block} not part of simulation"
             self.logger.error(_msg)
             raise ValueError(_msg)
 
         #remove from global blocklist
-        self.blocks.discard(block)
+        self.blocks.remove(block)
+        self._block_set.discard(block)
 
         #remove from dynamic list
-        self._blocks_dyn.discard(block)
+        if block in self._blocks_dyn_set:
+            self._blocks_dyn.remove(block)
+            self._blocks_dyn_set.discard(block)
 
         #remove from eventful list
-        self._blocks_evt.discard(block)
+        if block in self._blocks_evt_set:
+            self._blocks_evt.remove(block)
+            self._blocks_evt_set.discard(block)
 
         #mark graph for rebuild
         if self.graph:
@@ -549,13 +562,14 @@ def add_connection(self, connection):
         """
 
         #check if connection already in connection list
-        if connection in self.connections:
+        if connection in self._conn_set:
             _msg = f"{connection} already part of simulation"
             self.logger.error(_msg)
             raise ValueError(_msg)
 
         #add connection to global connection list
-        self.connections.add(connection)
+        self.connections.append(connection)
+        self._conn_set.add(connection)
 
         #mark graph for rebuild
         if self.graph:
@@ -575,13 +589,14 @@ def remove_connection(self, connection):
         """
 
         #check if connection is in connection list
-        if connection not in self.connections:
+        if connection not in self._conn_set:
             _msg = f"{connection} not part of simulation"
             self.logger.error(_msg)
             raise ValueError(_msg)
 
         #remove from global connection list
-        self.connections.discard(connection)
+        self.connections.remove(connection)
+        self._conn_set.discard(connection)
 
         #mark graph for rebuild
         if self.graph:
@@ -600,13 +615,14 @@ def add_event(self, event):
         """
 
         #check if event already in event list
-        if event in self.events:
+        if event in self._event_set:
             _msg = f"{event} already part of simulation"
             self.logger.error(_msg)
             raise ValueError(_msg)
 
         #add event to global event list
-        self.events.add(event)
+        self.events.append(event)
+        self._event_set.add(event)
 
 
     def remove_event(self, event):
@@ -621,13 +637,14 @@ def remove_event(self, event):
         """
 
         #check if event is in event list
-        if event not in self.events:
+        if event not in self._event_set:
             _msg = f"{event} not part of simulation"
             self.logger.error(_msg)
             raise ValueError(_msg)
 
         #remove from global event list
-        self.events.discard(event)
+        self.events.remove(event)
+        self._event_set.discard(event)
 
 
     # system assembly -------------------------------------------------------------
@@ -685,10 +702,11 @@ def _check_blocks_are_managed(self):
             conn_blocks.update(conn.get_blocks())
 
         # Check subset actively managed
-        if not conn_blocks.issubset(self.blocks):
-            self.logger.warning(
-                f"{blk} in 'connections' but not in 'blocks'!"
-                )
+        for blk in conn_blocks:
+            if blk not in self._block_set:
+                self.logger.warning(
+                    f"{blk} in 'connections' but not in 'blocks'!"
+                    )
 
 
     # solver management -----------------------------------------------------------
@@ -719,13 +737,15 @@ def _set_solver(self, Solver=None, **solver_kwargs):
         self.engine = self.Solver()
 
         #iterate all blocks and set integration engines with tolerances
-        self._blocks_dyn = set()
+        self._blocks_dyn = []
+        self._blocks_dyn_set = set()
         for block in self.blocks:
             block.set_solver(self.Solver, self.engine, **self.solver_kwargs)
-            
+
             #add dynamic blocks to list
             if block.engine:
-                self._blocks_dyn.add(block)
+                self._blocks_dyn.append(block)
+                self._blocks_dyn_set.add(block)
 
         #logging message
         self.logger.info(
diff --git a/src/pathsim/subsystem.py b/src/pathsim/subsystem.py
@@ -181,27 +181,28 @@ def __init__(self,
         #internal algebraic loop solvers -> initialized later
         self.boosters = None
 
-        #internal connecions
-        self.connections = set() 
-        if connections:
-            self.connections.update(connections)
-        
+        #internal connecions (ordered list with shadow set for O(1) lookup)
+        self.connections = list(connections) if connections else []
+        self._conn_set   = set(self.connections)
+
         #collect and organize internal blocks
-        self.blocks = set()
-        self.interface = None
+        self.blocks     = []
+        self._block_set = set()
+        self.interface  = None
 
         if blocks:
             for block in blocks:
-                if isinstance(block, Interface): 
-                    
+                if isinstance(block, Interface):
+
                     if self.interface is not None:
                         #interface block is already defined
                         raise ValueError("Subsystem can only have one 'Interface' block!")
-                    
+
                     self.interface = block
-                else: 
+                else:
                     #regular blocks
-                    self.blocks.add(block)
+                    self.blocks.append(block)
+                    self._block_set.add(block)
 
         #check if interface is defined
         if self.interface is None:
@@ -252,7 +253,7 @@ def __contains__(self, other):
         -------
         bool
         """
-        return other in self.blocks or other in self.connections
+        return other in self._block_set or other in self._conn_set
 
 
     # adding and removing system components ---------------------------------------------------
@@ -267,7 +268,7 @@ def add_block(self, block):
         block : Block
             block to add to the subsystem
         """
-        if block in self.blocks:
+        if block in self._block_set:
             raise ValueError(f"block {block} already part of subsystem")
 
         #initialize solver if available
@@ -276,7 +277,8 @@ def add_block(self, block):
             if block.engine:
                 self._blocks_dyn.append(block)
 
-        self.blocks.add(block)
+        self.blocks.append(block)
+        self._block_set.add(block)
 
         if self.graph:
             self._graph_dirty = True
@@ -292,10 +294,11 @@ def remove_block(self, block):
         block : Block
             block to remove from the subsystem
         """
-        if block not in self.blocks:
+        if block not in self._block_set:
             raise ValueError(f"block {block} not part of subsystem")
 
-        self.blocks.discard(block)
+        self.blocks.remove(block)
+        self._block_set.discard(block)
 
         #remove from dynamic list
         if hasattr(self, '_blocks_dyn') and block in self._blocks_dyn:
@@ -315,10 +318,11 @@ def add_connection(self, connection):
         connection : Connection
             connection to add to the subsystem
         """
-        if connection in self.connections:
+        if connection in self._conn_set:
             raise ValueError(f"{connection} already part of subsystem")
 
-        self.connections.add(connection)
+        self.connections.append(connection)
+        self._conn_set.add(connection)
 
         if self.graph:
             self._graph_dirty = True
@@ -334,10 +338,11 @@ def remove_connection(self, connection):
         connection : Connection
             connection to remove from the subsystem
         """
-        if connection not in self.connections:
+        if connection not in self._conn_set:
             raise ValueError(f"{connection} not part of subsystem")
 
-        self.connections.discard(connection)
+        self.connections.remove(connection)
+        self._conn_set.discard(connection)
 
         if self.graph:
             self._graph_dirty = True
@@ -386,7 +391,7 @@ def _assemble_graph(self):
         for block in self.blocks:
             block.inputs.reset()
 
-        self.graph = Graph({*self.blocks, self.interface}, self.connections)
+        self.graph = Graph([*self.blocks, self.interface], self.connections)
         self._graph_dirty = False
 
         #create boosters for loop closing connections
diff --git a/tests/pathsim/test_simulation.py b/tests/pathsim/test_simulation.py
@@ -52,9 +52,9 @@ def test_init_default(self):
 
         #test default initialization
         Sim = Simulation(log=False)
-        self.assertEqual(Sim.blocks, set())
-        self.assertEqual(Sim.connections, set())
-        self.assertEqual(Sim.events, set())
+        self.assertEqual(Sim.blocks, [])
+        self.assertEqual(Sim.connections, [])
+        self.assertEqual(Sim.events, [])
         self.assertEqual(Sim.dt, SIM_TIMESTEP)
         self.assertEqual(Sim.dt_min, SIM_TIMESTEP_MIN)
         self.assertEqual(Sim.dt_max, SIM_TIMESTEP_MAX)
@@ -130,12 +130,12 @@ def test_add_block(self):
         
         Sim = Simulation(log=False)
 
-        self.assertEqual(Sim.blocks, set())
+        self.assertEqual(Sim.blocks, [])
 
         #test adding a block
         B1 = Block()
         Sim.add_block(B1)
-        self.assertEqual(Sim.blocks, {B1})
+        self.assertEqual(Sim.blocks, [B1])
 
         #test adding the same block again
         with self.assertRaises(ValueError):
@@ -153,17 +153,17 @@ def test_add_connection(self):
             log=False
             )
 
-        self.assertEqual(Sim.connections, {C1})
+        self.assertEqual(Sim.connections, [C1])
 
         #test adding a connection
         C2 = Connection(B2, B3)
         Sim.add_connection(C2)
-        self.assertEqual(Sim.connections, {C1, C2})
+        self.assertEqual(Sim.connections, [C1, C2])
 
         #test adding the same connection again
         with self.assertRaises(ValueError):
             Sim.add_connection(C2)
-        self.assertEqual(Sim.connections, {C1, C2})
+        self.assertEqual(Sim.connections, [C1, C2])
 
 
     def test_set_solver(self): 
