MNT: final fixes before next release

Documentation, CHANGELOG and test polish ahead of the next release
(v1.13.0), covering PRs merged since v1.12.0.

CHANGELOG
- Add missing entries: Individual Fins (#818), AIGFS/HRRR forecast
  models (#951), duplicate-controller fix (#949), Valkyrie flight
  example (#967).
- Hygiene: de-duplicate #958/#966, move #974 to Fixed and #1041 to
  Removed only, drop the already-released #914 duplicate, and point the
  logging (#973) and ND-interp (#969) entries at their PRs.
- Backfill #940/#941/#944 (shipped in v1.12.0 code but never logged)
  under the [v1.12.0] section.

Docs
- New exceptions reference page (rocketpy.exceptions) wired into the
  reference index; note UnstableRocketWarning in the rocket stability
  docs (#970).
- tanks.rst: switch examples to radius_function= and add a deprecation
  note (#957).
- forecast.rst: fix the HRRR example (missing code directive + stray
  sentence) (#951).
- airbrakes.rst: document discrete vs continuous controllers
  (sampling_rate=None) (#946).
- rocket_usage.rst: note that Parachute is now an abstract base;
  instantiate HemisphericalParachute (#958).

Tests
- New regression tests: 3D ND-interp NaN outside convex hull (#969),
  abstract Parachute cannot be instantiated (#958), Monte Carlo
  convergence stopping (#922), EnvironmentAnalysis surviving wind API
  (#1041), radial-burn grain geometry over time (#944), RingClusterMotor
  full flight (#924), discrete controller invoked once per node (#949),
  acceleration-based parachute trigger deploys (#911).
- Backfill regression tests for ThrustCurve API timeouts (#940) and
  power_off/on_drag Function objects + _input attributes (#941).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Gui-FernandesBR

CHANGELOG.md

@@ -32,27 +32,25 @@ Attention: The newest changes should be on top -->
 
 ### Added
 
-- ENH: MNT: refactor parachute implementation [#958](https://github.com/RocketPy-Team/RocketPy/pull/958)
+- ENH: Individual Fins: add `Fin`, `TrapezoidalFin`, `EllipticalFin`, and `FreeFormFin` classes for modeling asymmetric or individually-positioned fins [#818](https://github.com/RocketPy-Team/RocketPy/pull/818)
+- ENH: Add AIGFS and HRRR forecast models to the Environment class [#951](https://github.com/RocketPy-Team/RocketPy/pull/951)
+- ENH: Add RingClusterMotor for annular clustered motor modeling [#924](https://github.com/RocketPy-Team/RocketPy/pull/924)
+- ENH: Discrete and Continuous Controllers [#946](https://github.com/RocketPy-Team/RocketPy/pull/946)
 - ENH: Add custom exceptions and unstable rocket warning [#970](https://github.com/RocketPy-Team/RocketPy/pull/970)
-- ENH: MNT: Remove redundant wind_heading/wind_direction functions from EnvironmentAnalysis [#1041](https://github.com/RocketPy-Team/RocketPy/pull/1041)
+- ENH: Adopt built-in Python logging instead of print() calls (closes [#450](https://github.com/RocketPy-Team/RocketPy/issues/450)) [#973](https://github.com/RocketPy-Team/RocketPy/pull/973)
 - ENH: Pass acceleration (`u_dot`) data to parachute trigger functions [#911](https://github.com/RocketPy-Team/RocketPy/pull/911)
 - ENH: Add 3D flight trajectory and attitude animations in Flight plots layer [#909](https://github.com/RocketPy-Team/RocketPy/pull/909)
-- ENH: DOC: Configure AI instructions and update developer docs [#975](https://github.com/RocketPy-Team/RocketPy/pull/975)
-- ENH: BUG: fix wind heading and direction wraparound interpolation [#974](https://github.com/RocketPy-Team/RocketPy/pull/974)
-- ENH: MNT: Sync develop's Renovate config with master (#1039) [#1040](https://github.com/RocketPy-Team/RocketPy/pull/1040)
-- ENH: MNT: Configure Renovate Bot targeting develop branch [#972](https://github.com/RocketPy-Team/RocketPy/pull/972)
-- MNT: Refactor parachute implementation with abstract base and hemispherical model split [#958](https://github.com/RocketPy-Team/RocketPy/pull/958)
 - ENH: Monte Carlo Formatting Options [#947](https://github.com/RocketPy-Team/RocketPy/pull/947)
-- ENH: ENH: Auto-Detection of Pressure Conversion Factor [#966](https://github.com/RocketPy-Team/RocketPy/pull/966)
+- ENH: Adaptive Monte Carlo via Convergence Criteria [#922](https://github.com/RocketPy-Team/RocketPy/pull/922)
 - ENH: Auto-Detection of Pressure Conversion Factor [#966](https://github.com/RocketPy-Team/RocketPy/pull/966)
-- ENH: Discrete and Continuous Controllers [#946](https://github.com/RocketPy-Team/RocketPy/pull/946)
+- ENH: Introduce pressure unit conversion when using forecast/reanalysis/ensemble data [#955](https://github.com/RocketPy-Team/RocketPy/pull/955)
+- MNT: Refactor parachute implementation with abstract base and hemispherical model split [#958](https://github.com/RocketPy-Team/RocketPy/pull/958)
 - DOC: Add aerodynamic surfaces user guide [#1043](https://github.com/RocketPy-Team/RocketPy/pull/1043)
-- ENH: Add RingClusterMotor for annular clustered motor modeling [#924](https://github.com/RocketPy-Team/RocketPy/pull/924)
-- ENH: MNT: introduce pressure unit conversion when using forecast/reanalysis/ensemble data [#955](https://github.com/RocketPy-Team/RocketPy/pull/955)
+- DOC: Add Valkyrie flight example (Bisky Team) [#967](https://github.com/RocketPy-Team/RocketPy/pull/967)
+- DOC: Configure AI instructions and update developer docs [#975](https://github.com/RocketPy-Team/RocketPy/pull/975)
 - ENH: Auto Populate Changelog [#919](https://github.com/RocketPy-Team/RocketPy/pull/919)
-- ENH: Adaptive Monte Carlo via Convergence Criteria [#922](https://github.com/RocketPy-Team/RocketPy/pull/922)
-- TST: Add acceptance tests for 3DOF flight simulation based on Bella Lui rocket [#914](https://github.com/RocketPy-Team/RocketPy/pull/914)
-- ENH: adopt built-in Python logging instead of print() calls [#450](https://github.com/RocketPy-Team/RocketPy/issues/450)
+- MNT: Sync develop's Renovate config with master (#1039) [#1040](https://github.com/RocketPy-Team/RocketPy/pull/1040)
+- MNT: Configure Renovate Bot targeting develop branch [#972](https://github.com/RocketPy-Team/RocketPy/pull/972)
 
 ### Changed
 
@@ -68,8 +66,9 @@ Attention: The newest changes should be on top -->
 
 ### Fixed
 
+- BUG: Remove duplicate controller process; controllers were being invoked twice per time node [#949](https://github.com/RocketPy-Team/RocketPy/pull/949)
 - BUG: fix wind heading and direction wraparound interpolation [#974](https://github.com/RocketPy-Team/RocketPy/pull/974)
-- BUG: fix NaN in ND linear interpolation outside convex hull [#926](https://github.com/RocketPy-Team/RocketPy/issues/926)
+- BUG: fix NaN in ND linear interpolation outside convex hull (closes [#926](https://github.com/RocketPy-Team/RocketPy/issues/926)) [#969](https://github.com/RocketPy-Team/RocketPy/pull/969)
 - BUG: Add wraparound logic for wind direction in environment plots [#939](https://github.com/RocketPy-Team/RocketPy/pull/939)
 
 ## [v1.12.1] - 2026-04-03
@@ -109,6 +108,9 @@ Attention: The newest changes should be on top -->
 ### Fixed
 
 - BUG: Fix hard-coded radius value for parachute added mass calculation [#889](https://github.com/RocketPy-Team/RocketPy/pull/889)
+- BUG: Fix incorrect Jacobian in `only_radial_burn` branch of `SolidMotor.evaluate_geometry` [#944](https://github.com/RocketPy-Team/RocketPy/pull/944)
+- ENH: Restore `power_off_drag`/`power_on_drag` as `Function` objects and preserve raw user input in `_input` attributes [#941](https://github.com/RocketPy-Team/RocketPy/pull/941)
+- ENH: Add explicit timeouts to ThrustCurve API requests [#940](https://github.com/RocketPy-Team/RocketPy/pull/940)
 - DOC: Fix documentation build [#908](https://github.com/RocketPy-Team/RocketPy/pull/908)
 - BUG: energy_data plot not working for 3 dof sims [[#906](https://github.com/RocketPy-Team/RocketPy/issues/906)]
 - BUG: Fix CSV column header spacing in FlightDataExporter [#864](https://github.com/RocketPy-Team/RocketPy/issues/864)

docs/reference/classes/exceptions.rst

@@ -0,0 +1,14 @@
+Exceptions and Warnings
+=======================
+
+RocketPy raises a small hierarchy of custom exceptions and warnings so that
+error handling can be more specific than catching plain ``ValueError`` or
+``UserWarning``. All exceptions inherit from :class:`~rocketpy.exceptions.RocketPyError`,
+which makes it possible to catch any RocketPy-specific error with a single
+``except`` clause while still deriving from the relevant built-in type
+(e.g. :class:`~rocketpy.exceptions.InvalidParameterError` is also a
+``ValueError``).
+
+.. automodule:: rocketpy.exceptions
+   :members:
+   :show-inheritance:

docs/reference/index.rst

@@ -18,9 +18,10 @@ This reference manual details functions, modules, methods and attributes include
    classes/Flight
    Utilities <classes/utils/index>
    classes/EnvironmentAnalysis
-   Monte Carlo Analysis <classes/monte_carlo/index> 
+   Monte Carlo Analysis <classes/monte_carlo/index>
    Sensitivity Analysis <classes/Sensitivity>
    Multivariate Rejection Sampler <classes/MultivariateRejectionSampler>
+   Exceptions and Warnings <classes/exceptions>
 
 .. toctree::
    :maxdepth: 2

docs/user/airbrakes.rst

@@ -95,9 +95,11 @@ To create an air brakes model, we essentially need to define the following:
   ``deployment_level`` attribute. Inside this function, any controller logic,
   filters, and apogee prediction can be implemented.
 
-- The **sampling rate** of the controller function, in seconds. This is the time
-  between each call of the controller function, in simulation time. Must be
-  given in Hertz.
+- The **sampling rate** of the controller function, in Hertz. This is how often
+  the controller function is called in simulation time (a **discrete**
+  controller). It can also be set to ``None`` to create a **continuous**
+  controller that is called at every solver step (see
+  :ref:`discrete-vs-continuous-controllers` below).
 
 Defining the Controller Function
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -108,8 +110,9 @@ The ``controller_function`` must take in the following arguments, in this
 order:
 
 1. ``time`` (float): The current simulation time in seconds.
-2. ``sampling_rate`` (float): The rate at which the controller
-   function is called, measured in Hertz (Hz).
+2. ``sampling_rate`` (float or ``None``): The rate at which the controller
+   function is called, measured in Hertz (Hz). It is ``None`` for continuous
+   controllers, so guard any ``1 / sampling_rate`` computation against ``None``.
 3. ``state`` (list): The state vector of the simulation. The state
    is a list containing the following values, in this order:
 
@@ -372,6 +375,41 @@ controller function. If you want to disable this feature, set ``clamp`` to
     For more information on the :class:`rocketpy.AirBrakes` class
     initialization, see  :class:`rocketpy.AirBrakes.__init__` section.
 
+.. _discrete-vs-continuous-controllers:
+
+Discrete vs. Continuous Controllers
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``sampling_rate`` argument determines *when* the controller function is
+called during the flight simulation:
+
+- **Discrete controller** (``sampling_rate`` set to a number, e.g. ``10``):
+  the controller function is called at fixed intervals of ``1 / sampling_rate``
+  seconds. This mirrors a real flight computer that reads its sensors and
+  updates its actuators at a fixed frequency, and is the recommended choice
+  when you want the simulation to reflect the actual control-loop rate of your
+  hardware.
+- **Continuous controller** (``sampling_rate=None``): the controller function
+  is called at *every* solver step of the numerical integrator. Use this when
+  you want the control law to act as a continuous function of the state rather
+  than a sampled one (for example, when validating a control model
+  analytically).
+
+.. warning::
+
+    For continuous controllers, ``sampling_rate`` is passed to your controller
+    function as ``None``. Any computation such as ``1 / sampling_rate`` (a
+    common pattern for rate-limiting deployment, as shown above) must guard
+    against ``None`` to avoid a ``TypeError``.
+
+.. note::
+
+    Discrete controllers add their sampling instants as time nodes to the
+    simulation, so remember to set ``time_overshoot=False`` in the ``Flight``
+    (see below) to make the integrator stop exactly at those instants.
+    Continuous controllers do not add time nodes; they are evaluated on the
+    integrator's own steps.
+
 Simulating a Flight
 -------------------
 

docs/user/environment/1-atm-models/forecast.rst

@@ -173,14 +173,14 @@ hourly updates. It is generally best for day-of-launch weather assessment and
 rapidly changing local conditions.
 
 RocketPy supports HRRR through a dedicated THREDDS shortcut.
-Like NAM and RAP, HRRR is a regional model over North America.
+Like NAM and RAP, HRRR is a regional model over North America, so you need to
+specify latitude and longitude points within its coverage area. The same
+SpacePort America coordinates used above will be reused here.
 
-If you have a HIRESW-compatible dataset from another provider (or a local copy),
-you can still load it explicitly by passing the path/URL in ``file`` and an
-appropriate mapping in ``dictionary``.
+.. code-block:: python
 
     env_hrrr = Environment(
-        date=now_plus_twelve,
+        date=tomorrow,
         latitude=32.988528,
         longitude=-106.975056,
     )

docs/user/motors/tanks.rst

@@ -104,7 +104,13 @@ The predefined ``CylindricalTank`` class is easy to use and is defined as such:
 
 .. jupyter-execute::
 
-  cylindrical_geometry = CylindricalTank(radius=0.1, height=2.0, spherical_caps=False)
+  cylindrical_geometry = CylindricalTank(radius_function=0.1, height=2.0, spherical_caps=False)
+
+.. deprecated:: 1.13.0
+  The ``radius`` keyword argument of ``CylindricalTank`` and ``SphericalTank``
+  has been renamed to ``radius_function``. Passing ``radius=`` still works but
+  now raises a ``DeprecationWarning`` and will be removed in v2.0.0. Use
+  ``radius_function=`` instead (it accepts the same constant radius value).
 
 .. note::
   The ``spherical_caps`` parameter is optional and defaults to ``False``. If set
@@ -116,7 +122,7 @@ The predefined ``SphericalTank`` is defined with:
 
 .. jupyter-execute::
 
-    spherical_geometry = SphericalTank(radius=0.1)
+    spherical_geometry = SphericalTank(radius_function=0.1)
 
 .. seealso::
   :class:`rocketpy.CylindricalTank` and :class:`rocketpy.SphericalTank`

docs/user/rocket/rocket_usage.rst

@@ -290,6 +290,17 @@ Optionally, we can also define:
 - The parachute trigger system lag ``lag``.
 - The parachute trigger system noise ``noise``.
 
+.. note::
+
+    Since v1.13.0, :class:`~rocketpy.Parachute` is an **abstract base class**
+    and can no longer be instantiated directly. Instead, instantiate a concrete
+    parachute model such as :class:`~rocketpy.HemisphericalParachute` (used
+    below), which derives its geometry-dependent quantities (e.g. the added
+    mass during descent) from the parachute ``radius`` and ``height``. As a
+    convenience shortcut, ``Rocket.add_parachute(...)`` can still be called with
+    keyword arguments (``name``, ``cd_s``, ``trigger``, ...) and will build a
+    hemispherical parachute for you.
+
 Lets add two parachutes to the rocket, one that will be deployed at
 apogee and another that will be deployed at 800 meters above ground level:
 
@@ -435,6 +446,18 @@ First, lets guarantee that the rocket is stable, by plotting the static margin:
     If it is unreasonably **high**, your rocket is **super stable** and the
     simulation will most likely **fail**.
 
+.. note::
+
+    RocketPy helps you catch this automatically: if the static margin is
+    **negative at motor ignition**, an
+    :class:`~rocketpy.exceptions.UnstableRocketWarning` is issued when the
+    rocket is used in a simulation. The check is skipped when the rocket has
+    any ``GenericSurface`` aerodynamic surfaces, since their lift coefficient
+    derivative is not accounted for in the center of pressure calculation,
+    which makes the static margin unreliable in that case. See
+    :doc:`/reference/classes/exceptions` for the full list of RocketPy
+    exceptions and warnings.
+
 The lets check all the information available about the rocket:
 
 .. jupyter-execute::

tests/integration/motors/test_ring_cluster_motor.py

@@ -1,7 +1,7 @@
 # pylint: disable=invalid-name
 import pytest
 import numpy as np
-from rocketpy import SolidMotor, Function
+from rocketpy import Flight, Function, Rocket, SolidMotor
 from rocketpy.motors.ring_cluster_motor import RingClusterMotor
 
 
@@ -137,3 +137,73 @@ def test_cluster_propellant_inertia_dynamic(base_motor):
 
     assert np.isclose(cluster.propellant_I_11(t), expected_ixx)  # pylint: disable=not-callable
     assert np.isclose(cluster.propellant_I_33(t), expected_izz)
+
+
+def test_ring_cluster_motor_full_flight(
+    calisto_motorless,
+    calisto_nose_cone,
+    calisto_tail,
+    calisto_trapezoidal_fins,
+    example_plain_env,
+):
+    """Integration test for PR #924: a ``RingClusterMotor`` must work
+    end-to-end when mounted on a ``Rocket`` and flown to apogee. The clustered
+    motor scales the base motor's thrust and total impulse by the number of
+    motors, and the rocket must reach a positive apogee.
+
+    A lightweight base motor is used on purpose so the Calisto airframe stays
+    aerodynamically stable (positive static margin) with the extra aft mass.
+    """
+    # Lightweight base motor so the clustered aft mass keeps the rocket stable.
+    base = SolidMotor(
+        thrust_source=lambda t: 800 if t < 3 else 0,
+        burn_time=3,
+        dry_mass=0.2,
+        dry_inertia=(0.01, 0.01, 0.001),
+        grain_number=1,
+        grain_density=1700,
+        grain_outer_radius=0.02,
+        grain_initial_inner_radius=0.01,
+        grain_initial_height=0.1,
+        nozzle_radius=0.01,
+        grain_separation=0.001,
+        grains_center_of_mass_position=0.1,
+        center_of_dry_mass_position=0.1,
+        coordinate_system_orientation="nozzle_to_combustion_chamber",
+    )
+    number = 2
+    cluster = RingClusterMotor(motor=base, number=number, radius=0.03)
+
+    # Clustered thrust / total impulse scale with the number of motors.
+    assert np.isclose(cluster.thrust(1), base.thrust(1) * number)
+    assert np.isclose(cluster.total_impulse, base.total_impulse * number)
+
+    rocket = calisto_motorless
+    rocket.add_motor(cluster, position=-1.373)
+    # Add all aerodynamic surfaces at once so the intermediate (fin-less) state
+    # is never evaluated as unstable during construction.
+    rocket.add_surfaces(
+        [calisto_nose_cone, calisto_tail, calisto_trapezoidal_fins],
+        [1.160, -1.313, -1.168],
+    )
+    rocket.set_rail_buttons(
+        upper_button_position=0.082,
+        lower_button_position=-0.618,
+        angular_position=0,
+    )
+
+    # The clustered motor keeps the rocket aerodynamically stable.
+    assert rocket.static_margin(0) > 0
+
+    flight = Flight(
+        rocket=rocket,
+        environment=example_plain_env,
+        rail_length=5.2,
+        inclination=85,
+        heading=0,
+        terminate_on_apogee=True,
+    )
+
+    assert flight.rocket.motor is cluster
+    assert flight.t_final > 0
+    assert flight.apogee > flight.env.elevation

tests/integration/motors/test_solid_motor.py

@@ -56,3 +56,32 @@ def test_evaluate_geometry_updates_properties(cesaroni_m1670):
 
     # evaluate at intermediate time
     assert isinstance(motor.grain_inner_radius(0.5), float)
+
+
+def test_only_radial_burn_grain_geometry_time_evolution(cesaroni_m1670):
+    """Regression for PR #944 (corrected Jacobian of the ``only_radial_burn``
+    branch of ``evaluate_geometry``).
+
+    With radial-only burning the integrated grain geometry over the full burn
+    must have a constant grain height (no axial regression) and a monotonically
+    growing inner radius, bounded by the initial inner radius and the grain
+    outer radius. A wrong Jacobian corrupts this integration.
+    """
+    motor = cesaroni_m1670
+    motor.only_radial_burn = True
+    motor.evaluate_geometry()
+
+    times = np.linspace(0, motor.grain_burn_out, 30)
+    heights = np.array([motor.grain_height(t) for t in times])
+    radii = np.array([motor.grain_inner_radius(t) for t in times])
+
+    # Radial-only burn: grain height stays at its initial value the whole burn.
+    assert np.allclose(heights, motor.grain_initial_height, atol=1e-9)
+
+    # Inner radius grows monotonically (non-decreasing) and actually increases.
+    assert np.all(np.diff(radii) >= -1e-12)
+    assert radii[-1] > radii[0]
+
+    # Physical bounds on the inner radius.
+    assert np.isclose(radii[0], motor.grain_initial_inner_radius)
+    assert radii[-1] <= motor.grain_outer_radius + 1e-12