TST: minor fixes

Author: MateusStano

rocketpy/_encoders.py

@@ -208,6 +208,9 @@ def set_minimal_flight_attributes(flight, obj):
     flight._controllers = getattr(flight.rocket, "_controllers", [])[:]
     flight.sensors = flight.rocket.sensors.get_components()
     flight.sensors_by_name = flight.rocket.sensors_by_name
+    # No simulation was run, so there is no recorded sensor data. Set an empty
+    # mapping so code that reads ``sensor_data`` behaves like a real flight.
+    flight.sensor_data = {}
     # TODO: custom_events are lost when loading from .rpy because they hold
     # user-defined callables that are not currently serialized. Add proper
     # serialization/deserialization for custom_events and restore them here

rocketpy/control/controller.py

@@ -422,6 +422,16 @@ def to_dict(self, **kwargs):
             "sampling_rate": self.sampling_rate,
             "name": self.name,
             "controlled_objects_name": getattr(self, "controlled_objects_name", None),
+            # Hash(es) identifying the controlled object(s), so Rocket
+            # deserialization can reconnect the controller to the rocket's own
+            # reconstructed objects (see Rocket.from_dict).
+            "controlled_objects_hash": self._controlled_objects_hash(),
+            # Which expensive simulation values the controller reads; needed so a
+            # re-simulated flight computes them (e.g. state_history). Stored as a
+            # list because JSON has no set type.
+            "controller_needs": (
+                None if self.controller_needs is None else list(self.controller_needs)
+            ),
             "context": self.context.copy(),  # Preserve context state
             "enabled": self.enabled,
             "disable_on": disable_on,
@@ -430,6 +440,24 @@ def to_dict(self, **kwargs):
             # object reference matching in Rocket deserialization
         }
 
+    def _controlled_objects_hash(self):
+        """Return the identity hash of the controlled object(s), matching the
+        shape of ``controlled_objects`` (a single hash for a single object, a
+        list of hashes for a list). These hashes match the ones the encoder
+        stores in each object's signature, letting Rocket deserialization find
+        the reconstructed objects. Returns ``None`` for anything unhashable."""
+
+        def safe_hash(obj):
+            try:
+                return hash(obj)
+            except TypeError:
+                return None
+
+        controlled_objects = self.controlled_objects
+        if isinstance(controlled_objects, (list, tuple)):
+            return [safe_hash(obj) for obj in controlled_objects]
+        return safe_hash(controlled_objects)
+
     @classmethod
     def from_dict(cls, data, controlled_objects=None):
         """Reconstruct controller from dictionary.
@@ -455,6 +483,7 @@ def from_dict(cls, data, controlled_objects=None):
         enabled = data.get("enabled", True)
         disable_on = data.get("disable_on")
         enable_on = data.get("enable_on")
+        controller_needs = data.get("controller_needs")
 
         try:
             controller_function = from_hex_decode(controller_function)
@@ -476,7 +505,7 @@ def from_dict(cls, data, controlled_objects=None):
         if controlled_objects is None:
             controlled_objects = []
 
-        return cls(
+        controller = cls(
             controller_function=controller_function,
             controlled_objects=controlled_objects,
             sampling_rate=sampling_rate,
@@ -486,4 +515,28 @@ def from_dict(cls, data, controlled_objects=None):
             enabled=enabled,
             disable_on=disable_on,
             enable_on=enable_on,
+            controller_needs=controller_needs,
+        )
+        # Stash the serialized controlled-object hash(es) so Rocket.from_dict
+        # can reconnect the controller to the rocket's reconstructed objects.
+        controller._serialized_controlled_objects_hash = data.get(
+            "controlled_objects_hash"
         )
+        return controller
+
+    def rebind_controlled_objects(self, controlled_objects):
+        """Point the controller at reconstructed controlled object(s) and
+        refresh the callback name bindings.
+
+        Used when a rocket is loaded from a file: the controller is rebuilt
+        without its controlled objects (they are separate objects in the saved
+        data), so this reconnects it to the rocket's own objects, ensuring the
+        controller mutates them rather than orphaned copies.
+
+        Parameters
+        ----------
+        controlled_objects : object or list of object
+            The reconstructed object(s) the controller should control.
+        """
+        self.controlled_objects = controlled_objects
+        self._controlled_objects_bindings = self.__verify_controlled_objects_name()

rocketpy/plots/flight_plots.py

@@ -1500,12 +1500,21 @@ def sensor_data(self, *, filename=None):
             print("No sensors were registered in this flight.")
             return
 
+        # A flight loaded from a file without being re-simulated has no recorded
+        # measurements, so fall back to an empty mapping instead of raising.
+        sensor_data = getattr(self.flight, "sensor_data", None) or {}
+
         seen = []
         for sensor in self.flight.sensors:
             if sensor in seen:  # a multiply-added sensor is listed more than once
                 continue
             seen.append(sensor)
-            measured_data = self.flight.sensor_data[sensor]
+            measured_data = sensor_data.get(sensor)
+            if not measured_data:
+                print(
+                    f"\n\n{sensor.name}: no data available (flight was not simulated)."
+                )
+                continue
             print(f"\n\n{sensor.name} Sensor Data\n")
             if filename is None:
                 sensor.plots.all(data=measured_data)

rocketpy/prints/flight_prints.py

@@ -266,12 +266,20 @@ def sensors(self):
             print("No sensors were registered.")
             return
 
+        # A flight loaded from a file without being re-simulated has no recorded
+        # measurements, so fall back to an empty mapping instead of raising.
+        sensor_data = getattr(self.flight, "sensor_data", None) or {}
+
         for sensor in self.flight.sensors:
             sensor_name = sensor.name if sensor.name else "Unnamed Sensor"
-            measured_data = self.flight.sensor_data[sensor]
             print(f"Sensor: {sensor_name}")
             print(f"\tType: {sensor.__class__.__name__}")
             print(f"\tSampling Rate: {sensor.sampling_rate:.3f} Hz")
+            measured_data = sensor_data.get(sensor)
+            if not measured_data:
+                print("\tNo measurement data available (flight was not simulated).")
+                print()
+                continue
             print(f"\tMeasurements Recorded: {len(measured_data)}")
             sensor.prints.data_summary(data=measured_data)
             print()

rocketpy/rocket/rocket.py

@@ -1035,7 +1035,9 @@ def _evaluate_is_incidence_linear(self):
                     self, 0.0, probe_alpha, probe_mach, "yaw"
                 )
             else:
-                point_zero = neutral_point_and_slope(self, 0.0, 0.0, probe_mach, "pitch")
+                point_zero = neutral_point_and_slope(
+                    self, 0.0, 0.0, probe_mach, "pitch"
+                )
                 point_five = neutral_point_and_slope(
                     self, probe_alpha, 0.0, probe_mach, "pitch"
                 )
@@ -2639,7 +2641,14 @@ def controller_wrapper(**kwargs):
             state = kwargs.get("state")
             state_history = kwargs.get("state_history")
             observed_variables = controller_context.get("observed_variables", [])
-            interactive_objects = kwargs.get("interactive_objects", air_brakes)
+            # Prefer the controller's live ``controlled_objects`` (set by the
+            # callback) over the captured ``air_brakes``: after a flight is
+            # loaded from a file the two differ, and only the former is the air
+            # brakes the rocket actually uses for drag. For a normal flight they
+            # are the same object, so this is unchanged behavior.
+            interactive_objects = kwargs.get(
+                "interactive_objects", kwargs.get("controlled_objects", air_brakes)
+            )
             sensors = kwargs.get("sensors")
             environment = kwargs.get("environment")
 
@@ -3048,22 +3057,34 @@ def from_dict(cls, data):
             rocket.air_brakes.append(air_brake)
 
         for controller in data["_controllers"]:
-            interactive_objects_hash = getattr(controller, "_interactive_objects_hash")
-            if interactive_objects_hash is not None:
-                is_iterable = isinstance(interactive_objects_hash, Iterable)
-                if not is_iterable:
-                    interactive_objects_hash = [interactive_objects_hash]
-                for hash_ in interactive_objects_hash:
+            # Reconnect the controller to the rocket's own reconstructed objects
+            # by matching the hash(es) it stored for its controlled objects
+            # against the reconstructed objects (see _Controller.to_dict).
+            controlled_objects_hash = getattr(
+                controller, "_serialized_controlled_objects_hash", None
+            )
+            if controlled_objects_hash is not None:
+                is_iterable = isinstance(controlled_objects_hash, Iterable)
+                hashes = (
+                    controlled_objects_hash
+                    if is_iterable
+                    else [controlled_objects_hash]
+                )
+                found = []
+                for hash_ in hashes:
+                    if hash_ is None:  # unhashable controlled object; cannot match
+                        continue
                     if (hashed_obj := find_obj_from_hash(data, hash_)) is not None:
-                        if not is_iterable:
-                            controller.interactive_objects = hashed_obj
-                        else:
-                            controller.interactive_objects.append(hashed_obj)
+                        found.append(hashed_obj)
                     else:
                         warnings.warn(
-                            "Could not find controller interactive objects."
+                            "Could not find controller controlled objects. "
                             "Deserialization will proceed, results may not be accurate."
                         )
+                if found:
+                    controller.rebind_controlled_objects(
+                        found if is_iterable else found[0]
+                    )
             rocket._add_controllers(controller)
 
         return rocket

tests/unit/test_rail_buttons_bending_moments.py

@@ -147,12 +147,19 @@ def test_railbuttons_no_aero_contribution():
     """Test RailButtons provide zero aerodynamic contributions."""
     rb = RailButtons(buttons_distance=0.5)
 
-    rb.evaluate_center_of_pressure()
+    # Center of pressure sits at the surface origin.
     assert rb.cp == (0, 0, 0)
 
-    rb.evaluate_lift_coefficient()
-    assert rb.clalpha(1.0) == 0  # Zero lift derivative
-    assert rb.cl(0.1, 1.0) == 0  # Zero lift coefficient
+    # Every force and moment coefficient is identically zero.
+    full_state = (0.1, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0)  # alpha, beta, mach, re, rates
+    for name in ("cN", "cY", "cA", "cm", "cn", "cl"):
+        coefficient = getattr(rb, name)
+        assert coefficient.is_zero
+        assert coefficient(*full_state) == 0
+
+    # Zero stability derivatives, so rail buttons never shift the static margin.
+    assert rb.cN_alpha(*full_state) == 0
+    assert rb.cm_alpha(*full_state) == 0
 
 
 def test_rail_button_bending_moments_prints(flight_calisto_robust, capsys):