TST: rebuild calisto_linear_generic from extracted Barrowman curves

Replace the poorly defined calisto_linear_generic fixture, which kept the
Barrowman nose cone and tail and swapped only the fins for a
LinearGenericSurface with arbitrary made-up coefficients. The new fixture is a
standalone Calisto whose nose cone, tail and fins are all LinearGenericSurfaces
built from coefficient curves extracted off the standard Barrowman surfaces
(normal-force-curve slope, center of pressure, fin roll damping).

Each linear surface applies its force at its own origin and is placed at the
source surface's center-of-pressure station, so both the static-margin path and
the flight-moment path land at the same point as calisto_robust. The resulting
flight matches the standard Calisto (identical apogee, out-of-rail time and
ascent angle of attack), so the fixture now exercises the linear
generic-surface path against a known-good reference.

Also fix test_linear_generic_surface_flight_is_stable to check the angle of
attack only during the ascent off the rail: on the rail the freestream speed is
~0 and the angle of attack is reported as a degenerate 90 degrees for any
launcher, which previously failed the < 45 assertion.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: MateusStano

tests/fixtures/rockets/rocket_fixtures.py

@@ -1,7 +1,59 @@
 import numpy as np
 import pytest
 
-from rocketpy import Rocket
+from rocketpy import LinearGenericSurface, Rocket
+
+# TODO: review note: gotta test execution speed of changes in this branch
+
+def _linear_surface_from_barrowman(surface):
+    """Build a LinearGenericSurface that reproduces a Barrowman surface's aero.
+
+    Reads the coefficient curves off a standard (Barrowman) aerodynamic surface
+    -- its normal-force-curve slope ``clalpha`` as a function of Mach and, for fin
+    sets, its roll cant and damping coefficients -- and packs them into the
+    body-frame coefficient derivatives of an equivalent
+    :class:`LinearGenericSurface`. The pitch- and yaw-plane slopes follow the
+    Barrowman sign convention (``cN_alpha = clalpha`` and ``cY_beta = -clalpha``).
+
+    The returned surface applies its force at its own origin (center of pressure
+    ``(0, 0, 0)``); the caller is expected to add it at the surface's center of
+    pressure station (``barrowman_station - clalpha_cp``) so that its force
+    lands, and its static margin reads, at the same point as the Barrowman
+    surface. Its ``cpz`` (the distance from the surface origin to its center of
+    pressure) is exposed on the returned object as ``barrowman_cpz`` to make that
+    offset easy for the caller.
+
+    Parameters
+    ----------
+    surface : rocketpy.NoseCone, rocketpy.Tail or rocketpy fin set
+        A standard Barrowman aerodynamic surface to copy the aero curves from.
+
+    Returns
+    -------
+    rocketpy.LinearGenericSurface
+        A linear generic surface with the same normal force and (for fins) roll
+        behaviour as ``surface``, carrying the source surface's ``cpz`` as
+        ``barrowman_cpz``.
+    """
+    clalpha = surface.clalpha  # normal-force-curve slope, a Function of Mach
+    coefficients = {
+        "cN_alpha": clalpha,
+        "cY_beta": lambda mach: -clalpha.get_value_opt(mach),
+    }
+    # Fin sets carry roll coefficients: cant forcing (zero when uncanted) and
+    # roll-rate damping. Other surfaces have no roll_parameters.
+    if getattr(surface, "roll_parameters", None) is not None:
+        coefficients["cl_0"] = surface.cl_0
+        coefficients["cl_p"] = surface.cl_p
+    linear_surface = LinearGenericSurface(
+        reference_area=surface.reference_area,
+        reference_length=surface.reference_length,
+        coefficients=coefficients,
+        center_of_pressure=(0, 0, 0),
+        name=f"{surface.name}_linear",
+    )
+    linear_surface.barrowman_cpz = surface.cpz
+    return linear_surface
 
 
 @pytest.fixture
@@ -184,6 +236,89 @@ def calisto_robust(
     return calisto
 
 
+@pytest.fixture
+def calisto_linear_generic(
+    cesaroni_m1670,
+    calisto_nose_cone,
+    calisto_tail,
+    calisto_trapezoidal_fins,
+    calisto_main_chute,
+    calisto_drogue_chute,
+):
+    """Calisto built entirely from LinearGenericSurfaces instead of Barrowman ones.
+
+    This is the same rocket as ``calisto_robust`` -- same body, motor, rail
+    buttons and parachutes at the same stations -- but its nose cone, tail and
+    fin set are each replaced by a body-frame ``LinearGenericSurface``. The
+    coefficient curves of those linear surfaces are extracted from the matching
+    standard (Barrowman) surfaces: each linear surface reuses the standard
+    surface's normal-force-curve slope, center of pressure and (for the fins)
+    roll damping. Because the aero data is identical, this rocket's flight
+    closely tracks the standard Calisto's while exercising the linear
+    generic-surface aerodynamic path -- the one whose forces and moments are
+    built directly in the body frame from the coefficient derivatives, with no
+    wind-to-body rotation. It is a standalone rocket (it does not reuse the
+    shared ``calisto`` fixture), so a test may build both it and ``calisto_robust``
+    and compare their flights.
+
+    Parameters
+    ----------
+    cesaroni_m1670 : rocketpy.SolidMotor
+        The Calisto motor. This is a pytest fixture too.
+    calisto_nose_cone : rocketpy.NoseCone
+        The standard nose cone whose aero curves are copied. This is a pytest
+        fixture too.
+    calisto_tail : rocketpy.Tail
+        The standard boat tail whose aero curves are copied. This is a pytest
+        fixture too.
+    calisto_trapezoidal_fins : rocketpy.TrapezoidalFins
+        The standard fin set whose aero curves are copied. This is a pytest
+        fixture too.
+    calisto_main_chute : rocketpy.Parachute
+        The main parachute of the Calisto rocket. This is a pytest fixture too.
+    calisto_drogue_chute : rocketpy.Parachute
+        The drogue parachute of the Calisto rocket. This is a pytest fixture too.
+
+    Returns
+    -------
+    rocketpy.Rocket
+        The Calisto rocket whose nose cone, tail and fins are all
+        LinearGenericSurfaces.
+    """
+    calisto = Rocket(
+        radius=0.0635,
+        mass=14.426,
+        inertia=(6.321, 6.321, 0.034),
+        power_off_drag="data/rockets/calisto/powerOffDragCurve.csv",
+        power_on_drag="data/rockets/calisto/powerOnDragCurve.csv",
+        center_of_mass_without_motor=0,
+        coordinate_system_orientation="tail_to_nose",
+    )
+    calisto.add_motor(cesaroni_m1670, position=-1.373)
+    # Replace each Barrowman surface with an equivalent LinearGenericSurface. A
+    # Barrowman surface is placed by its origin and carries its center of
+    # pressure at ``cpz`` aft of that origin; a generic surface applies its force
+    # at its own origin. So each linear surface is added at the Barrowman
+    # surface's center-of-pressure station (station - cpz, with tail_to_nose
+    # csys = +1), which lands its force -- and its static margin -- at the same
+    # point as calisto_robust.
+    for surface, station in (
+        (calisto_nose_cone, 1.160),
+        (calisto_tail, -1.313),
+        (calisto_trapezoidal_fins, -1.168),
+    ):
+        linear_surface = _linear_surface_from_barrowman(surface)
+        calisto.add_surfaces(linear_surface, station - linear_surface.barrowman_cpz)
+    calisto.set_rail_buttons(
+        upper_button_position=0.082,
+        lower_button_position=-0.618,
+        angular_position=0,
+    )
+    calisto.parachutes.append(calisto_main_chute)
+    calisto.parachutes.append(calisto_drogue_chute)
+    return calisto
+
+
 @pytest.fixture
 def calisto_nose_to_tail_robust(
     calisto_nose_to_tail,

tests/unit/simulation/test_flight.py

@@ -7,7 +7,7 @@
 import pytest
 from scipy import optimize
 
-from rocketpy import Components, Flight, Function, Rocket
+from rocketpy import Components, Flight, Function, LinearGenericSurface, Rocket
 
 plt.rcParams.update({"figure.max_open_warning": 0})
 
@@ -648,6 +648,46 @@ def test_stability_static_margins(
         assert np.all(np.abs(moments) <= 1e-10)
 
 
+def test_linear_generic_surface_flight_is_stable(
+    calisto_linear_generic, example_plain_env
+):
+    """A Calisto whose fin set is a body-frame LinearGenericSurface flies stably.
+
+    The linear surface builds its forces and moments directly in the body frame
+    from the coefficient derivatives (no wind-to-body rotation). With a positive
+    normal-force slope placed aft it must give a positive static margin and the
+    rocket must reach a finite apogee while staying aligned with the flow (a
+    small angle of attack, i.e. no tumbling).
+    """
+    rocket = calisto_linear_generic
+    assert any(
+        isinstance(surface, LinearGenericSurface)
+        for surface, _ in rocket.aerodynamic_surfaces
+    )
+    assert rocket.static_margin(0) > 0
+
+    test_flight = Flight(
+        environment=example_plain_env,
+        rocket=rocket,
+        rail_length=5.2,
+        inclination=85,
+        heading=0,
+        terminate_on_apogee=True,
+    )
+
+    assert test_flight.apogee_time > test_flight.out_of_rail_time
+    assert np.isfinite(test_flight.apogee)
+    assert test_flight.apogee > example_plain_env.elevation
+    # A stable rocket keeps a small angle of attack throughout the ascent. Only
+    # the ascent off the rail is checked: while the rocket is still on the rail
+    # its speed is ~0, so the angle of attack is reported as a degenerate 90
+    # degrees (arccos of 0) for every launcher, stable or not.
+    aoa_source = test_flight.angle_of_attack.get_source()
+    ascent = aoa_source[:, 0] > test_flight.out_of_rail_time
+    angle_of_attack = aoa_source[ascent, 1]
+    assert np.nanmax(np.abs(angle_of_attack)) < 45
+
+
 def test_max_acceleration_power_off_time_with_controllers(
     flight_calisto_air_brakes,
 ):