ENH: Discrete and Continuous Controllers

[Malmahrouqi3]

Pull request type

• Code changes (bugfix, features)

Checklist

• Tests for the changes have been added (if needed)
• Lint (black rocketpy/ tests/) has passed locally

Current behavior

#274

New behavior

Usage

airbrake_controller = _Controller(
    controller_function=controller_function,
    sampling_rate=10, # raplace with None or remove for continuous control
    interactive_objects=air_brakes,
    initial_observed_variables=[0, 0, 0],
    name="Discrete Air Brakes Controller (10 Hz)",
)
calisto._add_controllers(airbrake_controller)
calisto.air_brakes.append(air_brakes)

Tested on the Airbrakes Example (docs/user/airbrakes.rst)

(Discrete 10 Hz sampling)
195 Calls
Apogee State
Apogee Time: 23.360 s
Apogee Altitude: 4400.391 m (ASL) | 3000.391 m (AGL)
Apogee Freestream Speed: 16.149 m/s
Apogee X position: -4.510 m
Apogee Y position: 488.084 m
Apogee latitude: 32.9946429°
Apogee longitude: -106.9750464°

Maximum altitude: 3000.39 m

(Discrete 100 Hz sampling)
1947 Calls
Apogee State
Apogee Time: 23.362 s
Apogee Altitude: 4400.620 m (ASL) | 3000.620 m (AGL)
Apogee Freestream Speed: 16.151 m/s
Apogee X position: -4.511 m
Apogee Y position: 488.145 m
Apogee latitude: 32.9946434°
Apogee longitude: -106.9750464°

Maximum altitude: 3000.62 m

(Discrete 1000 Hz sampling)
19462 Calls
Apogee State
Apogee Time: 23.362 s
Apogee Altitude: 4400.594 m (ASL) | 3000.594 m (AGL)
Apogee Freestream Speed: 16.150 m/s
Apogee X position: -4.511 m
Apogee Y position: 488.136 m
Apogee latitude: 32.9946433°
Apogee longitude: -106.9750464°

Maximum altitude: 2903.45 m

(Continuous inf sampling)
410 Calls

Apogee State
Apogee Time: 23.369 s
Apogee Altitude: 4401.779 m (ASL) | 3001.779 m (AGL)
Apogee Freestream Speed: 16.157 m/s
Apogee X position: -4.104 m
Apogee Y position: 488.409 m
Apogee latitude: 32.9946458°
Apogee longitude: -106.9750420°

Maximum altitude: 3001.78 m

(No Controller)
0 Calls
Apogee State
Apogee Time: 25.886 s
Apogee Altitude: 4705.474 m (ASL) | 3305.474 m (AGL)
Apogee Freestream Speed: 20.662 m/s
Apogee X position: -5.543 m
Apogee Y position: 588.779 m
Apogee latitude: 32.9955483°
Apogee longitude: -106.9750574°

Maximum altitude: 3305.47 m

Breaking change

• Yes
• No

Additional information

There is no node creation for continuous controllers hence this step is skipped in flight.py. Instead, they are called in each of the ODE solver step, hence not relying on fixed sampling rate.

[codecov]

Codecov Report

❌ Patch coverage is 61.53846% with 5 lines in your changes missing coverage. Please review.
✅ Project coverage is 81.41%. Comparing base (9cf3dd4) to head (88ef28d).
⚠️ Report is 98 commits behind head on develop.

Files with missing lines	Patch %	Lines
rocketpy/prints/controller_prints.py	0.00%	3 Missing ⚠️
rocketpy/control/controller.py	60.00%	2 Missing ⚠️

Additional details and impacted files

@@             Coverage Diff             @@
##           develop     #946      +/-   ##
===========================================
+ Coverage    80.27%   81.41%   +1.14%     
===========================================
  Files          104      118      +14     
  Lines        12769    15172    +2403     
===========================================
+ Hits         10250    12352    +2102     
- Misses        2519     2820     +301     

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[Copilot]

Pull request overview

Adds first-class support for discrete (fixed refresh rate) and continuous (called every solver step) controllers to RocketPy’s flight simulation, aligning with the controller architecture discussed in issue #274.

Changes:

• Invoke continuous controllers during the solver stepping loop (instead of via fixed time nodes).
• Add Rocket.add_discrete_controller and Rocket.add_continuous_controller helpers that build _Controller objects with finite vs inf sampling rates.
• Update _Controller to default sampling_rate to math.inf and document the “infinite sampling” behavior.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 8 comments.

File	Description
rocketpy/simulation/flight.py	Calls continuous controllers each solver step and skips time-node creation for sampling_rate=inf.
rocketpy/rocket/rocket.py	Adds Rocket-level APIs to register discrete vs continuous controllers.
rocketpy/control/controller.py	Defaults controller sampling rate to infinity and updates documentation accordingly.

Comments suppressed due to low confidence (1)

rocketpy/control/controller.py:81

• The added note in the docstring exceeds the typical line-length used elsewhere in the project (and likely will be reformatted by Ruff/Black). Please wrap this note to keep docstring formatting consistent/readable, and consider clarifying how sampling_rate=inf interacts with the existing 1/sampling_rate wording in the sampling_rate parameter description.

            .. note:: The function will be called according to the sampling rate
            specified. If unspecified, the default sampling rate is set to infinity, meaning that the
            controller function will be called at every step of the simulation.
        sampling_rate : float
            The sampling rate of the controller function in Hertz (Hz). This
            means that the controller function will be called every
            `1/sampling_rate` seconds.

[MateusStano]

Really clean! Just requested a couple of changes and it should be good to merge

[Malmahrouqi3]

Really clean! Just requested a couple of changes and it should be good to merge

Added the requested changes and ready to merge.

[Copilot]

Pull request overview

Copilot reviewed 3 out of 3 changed files in this pull request and generated 3 comments.

[Gui-FernandesBR]

Addressed the requested points and pushed follow-up commit 601acb0:\n\n- kept continuous controllers represented by sampling_rate=None\n- ensured continuous controllers do not create time nodes (covered by unit test)\n- updated controller docstring to document sampling_rate as optional/continuous semantics\n- optimized continuous-controller history handling in Flight to avoid rebuilding state history on every step while preserving the documented state-vector format\n\nLocal checks run:\n- pytest tests/unit/simulation/test_flight_time_nodes.py -q\n- pytest tests/unit/simulation/test_flight.py -q\n-
uff check rocketpy/ tests/ docs/\n\nIssue context: this PR targets #274 (Continuous and Discrete Control).\n\n@MateusStano could you please re-review?

[Gui-FernandesBR]

Reviewed the latest commit 601acb0: state-history handling is now efficient and consistent, continuous-controller node scheduling is covered by unit tests, and controller docs reflect optional sampling_rate behavior.

[Copilot]

Pull request overview

Copilot reviewed 4 out of 4 changed files in this pull request and generated 2 comments.

[Malmahrouqi3]

@Gui-FernandesBR
I took one of your recent commits and the behavior was odd. My last push was finalized with the intent to merge the PR.
If you wish to make any changes, please use the notebook to make sure everything is alright!
airbrakes3.ipynb

[Gui-FernandesBR]

Hi @Malmahrouqi3 — thanks for flagging the odd behavior and for attaching airbrakes3.ipynb, that made it fully reproducible. I found the root cause and pushed the fix on top of your commits as a fast-forward (no force-push), so your history is preserved.

Root cause: discrete and continuous handed the controller different state_history layouts

• The discrete path (__process_sensors_and_controllers_at_current_node) passes self.solution, whose rows are time-prefixed: [t, x, y, z, vx, vy, vz, ...].
• The continuous path passed a time-stripped history: [x, y, z, vx, vy, vz, ...].

So state_history[-1][5] resolved to vy for discrete but vz for continuous. Our airbrakes controller reads previous_vz = state_history[-1][5] and uses 0.01 * previous_vz**2. In continuous mode it was therefore squaring the vertical velocity (~280 m/s) instead of the small lateral component — so previous_vz**2 blew up (~80,000 vs ~950), the airbrakes slammed fully open, and apogee collapsed to ~1370 m AGL instead of ~3000 m. I reproduced this exactly with your notebook.

Worth stressing: this layout mismatch pre-dates the recent commits — the original continuous implementation stripped the time column too ([step[1:] for step in self.solution[:-1]]). It only became visible once the controller leaned on state_history for velocity.

Fix

Pass self.solution to continuous controllers, identical to the discrete path. Both paths now hand over the same time-prefixed layout — verified: state_history[-1] row length is 14 in both modes, and state_history[-1][1:] == state in 100% of calls. A single controller function now behaves the same whether discrete or continuous. This also drops the parallel _controller_state_history list (O(1) per step).

Also included in this push

• Merged develop and resolved the conflicts — the PR is mergeable again.
• Fixed a TypeError in controller.info() when sampling_rate=None (f"{None:.3f}"), via a new _Controller.is_continuous property used as the single source of truth for the continuous/discrete dispatch.
• Corrected the state_history docstrings (_Controller, Rocket.add_air_brakes) — they described time-stripped rows, which is exactly what led to the confusion. They now document the time-prefixed layout and that sampling_rate is None for continuous controllers.
• Added an integration test asserting continuous controllers are invoked every solver step, always receive sampling_rate=None, and receive the time-prefixed layout.
• CI is green (lint + pytest).

Everything is on top of your work — happy to adjust anything. Let me know what you think!