fix(motor): make burn_time optional; honour nozzle_position for non-generic kinds

Two related fixes surfaced during jarvis form refactor.

1. MotorModel.burn_time: float  →  Optional[float] = None.
   RocketPy's LiquidMotor / HybridMotor / SolidMotor all auto-detect
   burn_time from the thrust_source array span — forcing clients to
   supply it was wrong. GenericMotor still requires it; the service
   now raises a 422 at the API boundary when the GENERIC path receives
   None, instead of letting rocketpy error deeper in construction.

2. MotorService.from_motor_model: nozzle_position previously landed in
   motor_core only for the GenericMotor branch; Liquid / Hybrid / Solid
   silently ignored the user's value and took rocketpy's default of 0.
   Now forwarded via motor_core for every kind (conditionally, so a
   null still falls back to rocketpy's default). Removed the redundant
   nozzle_position kwarg on the GenericMotor constructor call.

3. Optional-forwarding convention: motor_core only carries burn_time /
   nozzle_position when the client actually supplied them, so rocketpy
   picks its own default otherwise instead of receiving None for
   number-typed args.

Verified against real rocketpy:
- LIQUID, burn_time=None  → LiquidMotor auto-detects burn window
- LIQUID, burn_time=2.0   → LiquidMotor builds with explicit window
- LIQUID, nozzle_position=0.3  →  LiquidMotor.nozzle_position == 0.3
- LIQUID, nozzle_position=None →  LiquidMotor.nozzle_position == 0
- GENERIC, burn_time=None → 422 'burn_time is required for generic motors.'

All 173 unit tests pass.

Author: aasitvora99

src/models/motor.py

@@ -20,7 +20,11 @@ class MotorModel(ApiBaseModel):
 
     # Required parameters
     thrust_source: List[List[float]]
-    burn_time: float
+    # burn_time is optional for Liquid/Hybrid/Solid motors — rocketpy
+    # auto-detects the burn window from the thrust_source array span.
+    # GenericMotor still requires it; the motor service re-raises an
+    # explicit error when the GENERIC path receives None.
+    burn_time: Optional[float] = None
     nozzle_radius: float
     dry_mass: float
     dry_inertia: Tuple[float, float, float] = (0, 0, 0)

src/services/motor.py

@@ -7,21 +7,83 @@
 from rocketpy.motors.liquid_motor import LiquidMotor
 from rocketpy.motors.hybrid_motor import HybridMotor
 from rocketpy import (
+    CylindricalTank,
+    Fluid,
+    Function,
     LevelBasedTank,
     MassBasedTank,
     MassFlowRateBasedTank,
-    UllageBasedTank,
+    SphericalTank,
     TankGeometry,
+    UllageBasedTank,
 )
 
 from fastapi import HTTPException, status
 
-from src.models.sub.tanks import TankKinds
+from src.models.sub.tanks import (
+    CustomTankGeometry,
+    CylindricalTankGeometry,
+    SphericalTankGeometry,
+    TankFluids,
+    TankKinds,
+)
 from src.models.motor import MotorKinds, MotorModel
 from src.views.motor import MotorSimulation
 from src.utils import collect_attributes
 
 
+def _build_rocketpy_tank_geometry(geometry):
+    """Convert an API geometry model into a rocketpy geometry object.
+
+    Dispatch mirrors the discriminated union in
+    ``src.models.sub.tanks.TankGeometryInput``.
+    """
+    if isinstance(geometry, CylindricalTankGeometry):
+        return CylindricalTank(
+            radius=geometry.radius,
+            height=geometry.height,
+            spherical_caps=geometry.spherical_caps,
+        )
+    if isinstance(geometry, SphericalTankGeometry):
+        return SphericalTank(radius=geometry.radius)
+    if isinstance(geometry, CustomTankGeometry):
+        return TankGeometry(geometry_dict=dict(geometry.geometry))
+    raise ValueError(
+        f"Unsupported tank geometry kind: {type(geometry).__name__}"
+    )
+
+
+def _build_rocketpy_fluid(fluids: TankFluids) -> Fluid:
+    """Convert an API TankFluids into a rocketpy Fluid.
+
+    Scalar density is passed through (Fluid stores it as a constant).
+    Sampled density is converted to a 1D Temperature → Density Function
+    and wrapped in a ``(T, P)`` callable because rocketpy's Fluid expects
+    density to be a function of both temperature and pressure. Pressure
+    is ignored here intentionally; only temperature-dependent density
+    is supported in this iteration.
+    """
+    density = fluids.density
+    if isinstance(density, list):
+        temperature_to_density = Function(
+            source=density,
+            interpolation='linear',
+            extrapolation='natural',
+            inputs=['Temperature (K)'],
+            outputs='Density (kg/m^3)',
+        )
+
+        def density_callable(temperature, pressure):  # noqa: ARG001
+            # pylint: disable=unused-argument
+            # Rocketpy's Fluid wraps this into a 2-input Function of
+            # (T, P); pressure is accepted for signature compatibility
+            # but intentionally ignored in this iteration.
+            return temperature_to_density.get_value(temperature)
+
+        return Fluid(name=fluids.name, density=density_callable)
+    return Fluid(name=fluids.name, density=density)
+
+
 class MotorService:
     _motor: RocketPyMotor
 
@@ -45,7 +107,6 @@ def from_motor_model(cls, motor: MotorModel) -> Self:
 
         motor_core = {
             "thrust_source": motor.thrust_source,
-            "burn_time": motor.burn_time,
             "nozzle_radius": motor.nozzle_radius,
             "dry_mass": motor.dry_mass,
             "dry_inertia": motor.dry_inertia,
@@ -54,6 +115,13 @@ def from_motor_model(cls, motor: MotorModel) -> Self:
             "interpolation_method": motor.interpolation_method,
             "reshape_thrust_curve": reshape_thrust_curve,
         }
+        # Only forward optional rocketpy args when the client supplied them.
+        # Leaving them out lets rocketpy pick its own default (burn_time
+        # auto-detected from thrust_source span; nozzle_position = 0).
+        if motor.burn_time is not None:
+            motor_core["burn_time"] = motor.burn_time
+        if motor.nozzle_position is not None:
+            motor_core["nozzle_position"] = motor.nozzle_position
 
         match MotorKinds(motor.motor_kind):
             case MotorKinds.LIQUID:
@@ -103,25 +171,34 @@ def from_motor_model(cls, motor: MotorModel) -> Self:
                     **optional_params,
                 )
             case _:
+                # GenericMotor requires burn_time even though it's optional
+                # for the other motor kinds — surface the constraint at the
+                # API boundary instead of letting rocketpy raise a
+                # confusing stack trace deeper in construction.
+                if motor.burn_time is None:
+                    raise HTTPException(
+                        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                        detail="burn_time is required for generic motors.",
+                    )
+                # nozzle_position is already forwarded via motor_core when
+                # the client supplied it; GenericMotor's own default (0)
+                # applies otherwise.
                 rocketpy_motor = GenericMotor(
                     **motor_core,
                     chamber_radius=motor.chamber_radius,
                     chamber_height=motor.chamber_height,
                     chamber_position=motor.chamber_position,
                     propellant_initial_mass=motor.propellant_initial_mass,
-                    nozzle_position=motor.nozzle_position,
                 )
 
         if motor.motor_kind not in (MotorKinds.SOLID, MotorKinds.GENERIC):
             for tank in motor.tanks or []:
                 tank_core = {
                     "name": tank.name,
-                    "geometry": TankGeometry(
-                        geometry_dict=dict(tank.geometry)
-                    ),
+                    "geometry": _build_rocketpy_tank_geometry(tank.geometry),
                     "flux_time": tank.flux_time,
-                    "gas": tank.gas,
-                    "liquid": tank.liquid,
+                    "gas": _build_rocketpy_fluid(tank.gas),
+                    "liquid": _build_rocketpy_fluid(tank.liquid),
                     "discretize": tank.discretize,
                 }