feat: parse DEVICE_ACT entries from SMV file (based on PR #101)

Adds Device.activation_times — a sorted list of (time, state) tuples
recording when a device activated or deactivated during the simulation.

Two bugs from PR #101 were fixed before merging:
- time was stored as str instead of float
- the first data field is a global device index (1-based across all
  devices), not a per-name group index; line devices with >1 entry
  would have caused an IndexError. Fixed by building a registration-
  order list during SMV parsing and looking up directly by global index.

Co-Authored-By: NoahHastings <NoahHastings@users.noreply.github.com>

Author: m-fehr

fdsreader/devc/device.py

@@ -25,6 +25,7 @@ def __init__(
         self.position = position
         self.orientation = orientation
         self._data_callback = lambda: None
+        self._activation_times: list[tuple[float, bool]] = []
 
     @property
     def data(self):
@@ -51,6 +52,26 @@ def xyz(self):
         """Alias for :class:`Device`.position."""
         return self.position
 
+    @property
+    def activation_times(self) -> list[tuple[float, bool]]:
+        """List of ``(time, state)`` tuples recording when this device activated or deactivated.
+
+        Each entry is a ``(float, bool)`` tuple where *time* is the simulation time in seconds
+        and *state* is ``True`` for activation and ``False`` for deactivation.
+        The list is sorted by time.
+        """
+        return self._activation_times
+
+    def add_activation_time(self, time: float, state: bool) -> None:
+        """Record an activation event for this device.
+
+        Args:
+            time: Simulation time of the event in seconds.
+            state: ``True`` if the device activated, ``False`` if it deactivated.
+        """
+        self._activation_times.append((time, state))
+        self._activation_times.sort(key=lambda a: a[0])
+
     def clear_cache(self):
         """Remove all data from the internal cache that has been loaded so far to free memory."""
         if hasattr(self, "_data"):

fdsreader/simulation.py

@@ -217,6 +217,8 @@ def __init__(self, path: str):
                 pickle.dump(self, open(Simulation._get_pickle_filename(self.root_path, self.chid), "wb"), protocol=4)
 
     def parse_smv_file(self):
+        # Global device list in registration order — used to resolve DEVICE_ACT indices.
+        _devices_by_global_index: list[Device] = []
         with open(self.smv_file_path) as smv_file:
             for line in smv_file:
                 keyword = line.strip()
@@ -265,6 +267,14 @@ def parse_smv_file(self):
                             self._devices[device_id] = [self._devices[device_id], device]
                     else:
                         self._devices[device_id] = device
+                    _devices_by_global_index.append(device)
+                elif keyword.startswith("DEVICE_ACT"):
+                    idx_str, time_str, value_str = smv_file.readline().split()
+                    global_index = int(idx_str) - 1  # FDS uses 1-based global device index
+                    act_time = float(time_str)
+                    act_state = bool(int(value_str))
+                    if global_index < len(_devices_by_global_index):
+                        _devices_by_global_index[global_index].add_activation_time(act_time, act_state)
                 elif keyword.startswith("SLC"):
                     self._load_slice(smv_file, keyword)
                 elif keyword.startswith("BNDS"):

tests/acceptance_tests/test_devc.py

@@ -41,3 +41,18 @@ def test_clear_cache_with_line_devices():
     sim = Simulation(os.path.join(TEST_DIR, "../cases/devc_data"))
     assert any(isinstance(d, list) for d in sim.devices), "Test data should contain line devices"
     sim.clear_cache()
+
+
+def test_activation_times_type(devc_sim):
+    """activation_times entries must be (float, bool) tuples (PR #101)."""
+    for entry in devc_sim.devices["TC_Room"]:
+        for t, s in entry.activation_times:
+            assert isinstance(t, float), f"Expected float time, got {type(t)}"
+            assert isinstance(s, bool), f"Expected bool state, got {type(s)}"
+
+
+def test_activation_times_monotonic(devc_sim):
+    """activation_times must be sorted by time (PR #101)."""
+    for entry in devc_sim.devices["TC_Room"]:
+        times = [t for t, _ in entry.activation_times]
+        assert times == sorted(times), "activation_times not sorted by time"