external data to signals name (#179)

Author: paulf81

hercules/hercules_model.py

@@ -70,12 +70,12 @@ def __init__(self, input_file):
         self._controller = None
 
         # Read in any external data
-        self.external_data_all = {}
+        self.external_signals_all = {}
         self.external_data_log_channels = None
+        self.h_dict["external_signals"] = {}
         if "external_data" in self.h_dict:
             self._read_external_data_file(self.h_dict["external_data"]["external_data_file"])
             self.external_data_log_channels = self.h_dict["external_data"]["log_channels"]
-            self.h_dict["external_signals"] = {}
 
         # Initialize HDF5 output configuration
         if "output_file" in self.h_dict:
@@ -184,7 +184,7 @@ def _read_external_data_file(self, filename):
         This method reads external data from the specified file (CSV, feather, or pickle)
         and interpolates it according to the simulation time steps. The external data must
         include a 'time_utc' column which will be converted to simulation time.
-        The interpolated data is stored in self.external_data_all.
+        The interpolated data is stored in self.external_signals_all.
 
         Args:
             filename (str): Path to the file containing external data. Supported formats:
@@ -228,7 +228,7 @@ def _read_external_data_file(self, filename):
 
         # Convert interpolated DataFrame to dictionary format
         for col in df_interpolated.columns:
-            self.external_data_all[col] = df_interpolated[col].values
+            self.external_signals_all[col] = df_interpolated[col].values
 
     def _initialize_hdf5_file(self):
         """Initialize HDF5 file with metadata and data structure."""
@@ -494,7 +494,7 @@ def run(self):
             controller_step = self.controller.step
             plant_step = self.hybrid_plant.step
             log_current_state = self._log_data_to_hdf5
-            external_data_all = self.external_data_all
+            external_signals_all = self.external_signals_all
             h_dict = self.h_dict
 
             # Set current time and run simulation through steps
@@ -517,11 +517,11 @@ def run(self):
                         last_progress_update = self.step
 
                 # Fast external data lookup by step index (avoids per-step array equality checks)
-                if external_data_all:
-                    for k in external_data_all:
+                if external_signals_all:
+                    for k in external_signals_all:
                         if k == "time":
                             continue
-                        h_dict["external_signals"][k] = external_data_all[k][self.step]
+                        h_dict["external_signals"][k] = external_signals_all[k][self.step]
 
                 # Update controller and py sims
                 h_dict["time"] = self.time

tests/hercules_model_test.py

@@ -81,7 +81,7 @@ def test_HerculesModel_instantiation():
     # Check default settings
     assert hmodel.output_file == "outputs/hercules_output.h5"
     assert hmodel.log_every_n == 1
-    assert hmodel.external_data_all == {}
+    assert hmodel.external_signals_all == {}
 
     # Test with external data file and custom output file
     test_h_dict_2 = h_dict_solar.copy()
@@ -99,12 +99,12 @@ def test_HerculesModel_instantiation():
     hmodel = HerculesModel(test_h_dict_2)
 
     # Check external data loading
-    assert hmodel.external_data_all["power_reference"][0] == 1000
+    assert hmodel.external_signals_all["power_reference"][0] == 1000
     # With dt=0.5 and endtime=5.0, we have times: 0.0, 0.5, 1.0, ..., 5.5, 6.0
     # At time 1.0: value is 2000 (from data), but at index 2 (time=1.0), value is interpolated
-    # Actually external_data_all has times from starttime to endtime + 2*dt with step dt
+    # Actually external_signals_all has times from starttime to endtime + 2*dt with step dt
     # So times are: 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0
-    assert hmodel.external_data_all["power_reference"][-1] == 1000  # At time 6.0
+    assert hmodel.external_signals_all["power_reference"][-1] == 1000  # At time 6.0
 
     # Check custom output file
     assert hmodel.output_file == "test_output.h5"
@@ -194,11 +194,11 @@ def test_log_data_to_hdf5_with_external_signals():
     hmodel.h_dict["step"] = 5
 
     # Update external signals (simulate what happens in the run loop)
-    if hmodel.external_data_all:
-        for k in hmodel.external_data_all:
+    if hmodel.external_signals_all:
+        for k in hmodel.external_signals_all:
             if k == "time":
                 continue
-            hmodel.h_dict["external_signals"][k] = hmodel.external_data_all[k][hmodel.step]
+            hmodel.h_dict["external_signals"][k] = hmodel.external_signals_all[k][hmodel.step]
 
     # Run controller and hybrid_plant steps to generate plant-level outputs
     hmodel.h_dict = hmodel.controller.step(hmodel.h_dict)
@@ -221,7 +221,7 @@ def test_log_data_to_hdf5_with_external_signals():
         hmodel._flush_buffer_to_hdf5()
 
     # Check that external signal data was written correctly
-    expected_value = hmodel.external_data_all["power_reference"][5]  # Value at step 5
+    expected_value = hmodel.external_signals_all["power_reference"][5]  # Value at step 5
     assert hmodel.hdf5_datasets[expected_external_dataset][0] == expected_value
 
     # Clean up
@@ -574,9 +574,9 @@ def test_external_data_new_format_with_log_channels():
     # Verify that external_data_log_channels was set
     assert hmodel.external_data_log_channels == ["power_reference"]
 
-    # Verify that all external data was loaded into external_data_all
-    assert "power_reference" in hmodel.external_data_all
-    assert len(hmodel.external_data_all["power_reference"]) > 0
+    # Verify that all external data was loaded into external_signals_all
+    assert "power_reference" in hmodel.external_signals_all
+    assert len(hmodel.external_signals_all["power_reference"]) > 0
 
     # Clean up
     hmodel.close()
@@ -611,13 +611,13 @@ def test_external_data_backward_compatibility():
     assert hmodel.external_data_log_channels is None
 
     # Verify that data was loaded
-    assert "power_reference" in hmodel.external_data_all
+    assert "power_reference" in hmodel.external_signals_all
 
     # Clean up
     hmodel.close()
 
 
-def test_external_data_all_channels_in_h_dict():
+def test_external_signals_all_channels_in_h_dict():
     """Test that all external data channels are available in h_dict regardless of log_channels."""
     # Create a CSV with multiple channels
     import os
@@ -659,11 +659,11 @@ def test_external_data_all_channels_in_h_dict():
         hmodel.h_dict["step"] = 5
 
         # Populate external signals (as done in run loop)
-        if hmodel.external_data_all:
-            for k in hmodel.external_data_all:
+        if hmodel.external_signals_all:
+            for k in hmodel.external_signals_all:
                 if k == "time":
                     continue
-                hmodel.h_dict["external_signals"][k] = hmodel.external_data_all[k][hmodel.step]
+                hmodel.h_dict["external_signals"][k] = hmodel.external_signals_all[k][hmodel.step]
 
         # Verify ALL channels are in h_dict["external_signals"]
         assert "channel_1" in hmodel.h_dict["external_signals"]
@@ -733,11 +733,11 @@ def test_external_data_log_all_when_no_log_channels():
         hmodel.h_dict["step"] = 5
 
         # Populate external signals
-        if hmodel.external_data_all:
-            for k in hmodel.external_data_all:
+        if hmodel.external_signals_all:
+            for k in hmodel.external_signals_all:
                 if k == "time":
                     continue
-                hmodel.h_dict["external_signals"][k] = hmodel.external_data_all[k][hmodel.step]
+                hmodel.h_dict["external_signals"][k] = hmodel.external_signals_all[k][hmodel.step]
 
         # Run controller and hybrid_plant steps
         hmodel.h_dict = hmodel.controller.step(hmodel.h_dict)
@@ -801,11 +801,11 @@ def test_external_data_log_none_with_empty_list():
         hmodel.h_dict["step"] = 5
 
         # Populate external signals (all channels should be available)
-        if hmodel.external_data_all:
-            for k in hmodel.external_data_all:
+        if hmodel.external_signals_all:
+            for k in hmodel.external_signals_all:
                 if k == "time":
                     continue
-                hmodel.h_dict["external_signals"][k] = hmodel.external_data_all[k][hmodel.step]
+                hmodel.h_dict["external_signals"][k] = hmodel.external_signals_all[k][hmodel.step]
 
         # Verify ALL channels are in h_dict["external_signals"] (available to controller)
         assert "channel_x" in hmodel.h_dict["external_signals"]