ENH: Enable sensors+acceleration triggers in parachutes

Allow parachute triggers to accept (p, h, y, sensors, u_dot); Flight passes sensors+u_dot, computing u_dot on demand with noise; numeric/apogee legacy triggers carry metadata.\n\nTests: pytest tests/unit/test_parachute_trigger_acceleration.py -v\nLint: black rocketpy tests && ruff check rocketpy tests

Author: ViniciusCMB

rocketpy/rocket/parachute.py

@@ -7,6 +7,7 @@
 from ..mathutils.function import Function
 from ..prints.parachute_prints import _ParachutePrints
 
+
 def detect_motor_burnout(pressure, height, state_vector, u_dot):
     """Detect motor burnout by sudden drop in acceleration.
 
@@ -364,13 +365,12 @@ def __evaluate_trigger_function(self, trigger):
 
         Notes
         -----
-        The resulting triggerfunc always has signature (p, h, y, fourth) so
-        Flight can pass either the sensors list or the u_dot (derivative)
-        depending on the runtime behaviour.
+        The resulting triggerfunc always has signature (p, h, y, sensors, u_dot)
+        so Flight can pass both sensors and u_dot when needed.
         """
         # pylint: disable=unused-argument, function-redefined
 
-        # Helper to wrap any callable to the internal (p, h, y, fourth) API
+        # Helper to wrap any callable to the internal (p, h, y, sensors, u_dot) API
         def _make_wrapper(fn):
             sig = signature(fn)
             params = list(sig.parameters.keys())
@@ -380,22 +380,39 @@ def _make_wrapper(fn):
                 name.lower() in ("u_dot", "udot", "acc", "acceleration")
                 for name in params[3:]
             )
+            # detect if user function expects sensors argument
+            expects_sensors = any(name.lower() == "sensors" for name in params[3:])
 
-            def wrapper(p, h, y, fourth):  # fourth can be sensors or u_dot
-                # Support both 3- and 4-arg user functions
+            def wrapper(p, h, y, sensors, u_dot):
+                # Support 3, 4, and 5-arg user functions
                 num_params = len(sig.parameters)
                 if num_params == 3:
                     return fn(p, h, y)
                 if num_params == 4:
-                    return fn(p, h, y, fourth)
-                # fallback: try calling with four args, otherwise three
+                    # Check which 4th arg to pass
+                    fourth_param = params[3].lower()
+                    if fourth_param in ("u_dot", "udot", "acc", "acceleration"):
+                        return fn(p, h, y, u_dot)
+                    else:
+                        return fn(p, h, y, sensors)
+                if num_params >= 5:
+                    # Pass both sensors and u_dot
+                    return fn(p, h, y, sensors, u_dot)
+                # fallback: try calling with available args
                 try:
-                    return fn(p, h, y, fourth)
+                    return fn(p, h, y, sensors, u_dot)
                 except TypeError:
-                    return fn(p, h, y)
+                    try:
+                        return fn(p, h, y, u_dot)
+                    except TypeError:
+                        try:
+                            return fn(p, h, y, sensors)
+                        except TypeError:
+                            return fn(p, h, y)
 
             # attach metadata so Flight can decide whether to compute u_dot
             wrapper._expects_udot = expects_udot
+            wrapper._expects_sensors = expects_sensors
             wrapper._wrapped_fn = fn
             return wrapper
 
@@ -407,12 +424,14 @@ def wrapper(p, h, y, fourth):  # fourth can be sensors or u_dot
         # Numeric altitude trigger
         if isinstance(trigger, (int, float)):
 
-            def triggerfunc(p, h, y, sensors):  # pylint: disable=unused-argument
+            def triggerfunc(p, h, y, sensors, u_dot):  # pylint: disable=unused-argument
                 # p = pressure considering parachute noise signal
                 # h = height above ground level considering parachute noise signal
                 # y = [x, y, z, vx, vy, vz, e0, e1, e2, e3, w1, w2, w3]
                 return y[5] < 0 and h < trigger
 
+            triggerfunc._expects_udot = False
+            triggerfunc._expects_sensors = True
             self.triggerfunc = triggerfunc
             return
 
@@ -432,9 +451,11 @@ def triggerfunc(p, h, y, sensors):  # pylint: disable=unused-argument
         # Special case: "apogee" (legacy support)
         if isinstance(trigger, str) and trigger.lower() == "apogee":
 
-            def triggerfunc(p, h, y, sensors):  # pylint: disable=unused-argument
+            def triggerfunc(p, h, y, sensors, u_dot):  # pylint: disable=unused-argument
                 return y[5] < 0
 
+            triggerfunc._expects_udot = False
+            triggerfunc._expects_sensors = True
             self.triggerfunc = triggerfunc
             return
 

rocketpy/simulation/flight.py

@@ -1142,13 +1142,11 @@ def __calculate_and_save_pressure_signals(self, parachute, t, z):
     def _evaluate_parachute_trigger(
         self, parachute, pressure, height, y, sensors, derivative_func, t
     ):
-        """Evaluate parachute trigger, optionally computing u_dot (acceleration).
+        """Evaluate parachute trigger, passing both sensors and u_dot to wrapper.
 
         This helper preserves backward compatibility with existing trigger
-        signatures and will compute ``u_dot`` only if the prepared wrapper in
-        `Parachute` or the original trigger signature requests an acceleration
-        argument (detected by parameter name such as 'u_dot', 'udot', 'acc',
-        or 'acceleration').
+        signatures. The wrapper in Parachute always expects (p, h, y, sensors, u_dot)
+        and Flight computes u_dot only when the trigger requests it (optimization).
 
         Parameters
         ----------
@@ -1172,44 +1170,48 @@ def _evaluate_parachute_trigger(
         bool
             True if trigger condition met, False otherwise.
         """
-        # Prefer the wrapper metadata: check if the prepared wrapper expects u_dot
         triggerfunc = parachute.triggerfunc
+
+        # Check wrapper metadata for expectations
         expects_udot = getattr(triggerfunc, "_expects_udot", False)
+        expects_sensors = getattr(triggerfunc, "_expects_sensors", True)
 
-        # If the wrapper didn't advertise, inspect the original user trigger
-        if not expects_udot:
+        # Fallback: inspect original trigger signature if metadata missing
+        if not expects_udot and not expects_sensors:
             trig_original = getattr(parachute, "trigger", None)
             if callable(trig_original):
                 try:
                     sig = inspect.signature(trig_original)
-                    params = list(sig.parameters.values())
+                    params = list(sig.parameters.keys())
                     acc_names = {"u_dot", "udot", "acc", "acceleration"}
-                    if any(p.name.lower() in acc_names for p in params):
-                        expects_udot = True
+                    expects_udot = any(p.lower() in acc_names for p in params[3:])
+                    expects_sensors = any(p.lower() == "sensors" for p in params[3:])
                 except (ValueError, TypeError):
                     expects_udot = False
+                    expects_sensors = True
 
-        # If the trigger expects acceleration, compute u_dot and inject noise
+        # Compute u_dot only if needed (performance optimization)
+        u_dot = None
         if expects_udot:
             try:
                 u_dot = np.array(derivative_func(t, y), dtype=float)
-                try:
-                    noise = np.asarray(self.acceleration_noise_function())
-                    if noise.size == 3:
-                        # u_dot layout: [vx, vy, vz, ax, ay, az, ...]
-                        u_dot[3:6] = u_dot[3:6] + noise
-                except Exception:
-                    # ignore noise errors and continue
-                    pass
-                fourth_arg = u_dot
+                # Inject accelerometer noise if configured
+                if hasattr(self, "acceleration_noise_function"):
+                    try:
+                        noise = np.asarray(self.acceleration_noise_function())
+                        if noise.size == 3:
+                            # u_dot layout: [vx, vy, vz, ax, ay, az, ...]
+                            u_dot[3:6] = u_dot[3:6] + noise
+                    except Exception:
+                        # ignore noise errors and continue
+                        pass
             except Exception:
-                # Fallback to sensors if derivative computation fails
-                fourth_arg = sensors
-        else:
-            fourth_arg = sensors
+                # If u_dot computation fails, leave as None
+                u_dot = None
 
-        # Call the prepared wrapper (it will forward args to the user's fn)
-        return triggerfunc(pressure, height, y, fourth_arg)
+        # Call the wrapper with both sensors and u_dot
+        # The wrapper will decide which args to pass to the user's function
+        return triggerfunc(pressure, height, y, sensors, u_dot)
 
     def __init_solution_monitors(self):
         # Initialize solution monitors