partially fix tests

Author: Gui-FernandesBR

rocketpy/_encoders.py

@@ -3,6 +3,7 @@
 import json
 from datetime import datetime
 from importlib import import_module
+from inspect import Parameter, signature
 
 import numpy as np
 
@@ -71,11 +72,12 @@ def default(self, o):
                 encoding["signature"] = get_class_signature(o)
                 return encoding
         elif hasattr(o, "to_dict"):
-            encoding = o.to_dict(
-                include_outputs=self.include_outputs,
-                discretize=self.discretize,
-                allow_pickle=self.allow_pickle,
-            )
+            call_kwargs = {
+                "include_outputs": self.include_outputs,
+                "discretize": self.discretize,
+                "allow_pickle": self.allow_pickle,
+            }
+            encoding = _call_to_dict_with_supported_kwargs(o, call_kwargs)
             encoding = remove_circular_references(encoding)
 
             encoding["signature"] = get_class_signature(o)
@@ -195,6 +197,23 @@ def set_minimal_flight_attributes(flight, obj):
     flight.t_initial = flight.initial_solution[0]
 
 
+def _call_to_dict_with_supported_kwargs(obj, candidate_kwargs):
+    """Call obj.to_dict passing only supported keyword arguments."""
+    method = obj.to_dict
+    sig = signature(method)
+    params = list(sig.parameters.values())
+
+    if any(param.kind == Parameter.VAR_KEYWORD for param in params):
+        return method(**candidate_kwargs)
+
+    supported_kwargs = {
+        name: candidate_kwargs[name]
+        for name in sig.parameters
+        if name != "self" and name in candidate_kwargs
+    }
+    return method(**supported_kwargs)
+
+
 def get_class_signature(obj):
     """Returns the signature of a class so it can be identified on
     decoding. The signature is a dictionary with the module and

rocketpy/mathutils/inertia.py

@@ -0,0 +1,217 @@
+"""Utilities related to inertia tensor transformations.
+
+This module centralizes dynamic helpers for applying the parallel axis
+ theorem (PAT). It lives inside ``rocketpy.mathutils`` so that functionality
+ depending on :class:`rocketpy.mathutils.function.Function` does not leak into
+ generic utility modules such as ``rocketpy.tools``.
+"""
+
+from rocketpy.mathutils.function import Function
+from rocketpy.mathutils.vector_matrix import Vector
+
+
+def _pat_dynamic_helper(com_inertia_moment, mass, distance_vec_3d, axes_term_lambda):
+    """Apply the PAT to inertia moments, supporting static and dynamic inputs."""
+
+    is_dynamic = (
+        isinstance(com_inertia_moment, Function)
+        or isinstance(mass, Function)
+        or isinstance(distance_vec_3d, Function)
+    )
+
+    def get_val(arg, t):
+        return arg(t) if isinstance(arg, Function) else arg
+
+    if not is_dynamic:
+        d_vec = Vector(distance_vec_3d)
+        mass_term = mass * axes_term_lambda(d_vec)
+        return com_inertia_moment + mass_term
+
+    def new_source(t):
+        d_vec_t = get_val(distance_vec_3d, t)
+        mass_t = get_val(mass, t)
+        inertia_t = get_val(com_inertia_moment, t)
+        mass_term = mass_t * axes_term_lambda(d_vec_t)
+        return inertia_t + mass_term
+
+    return Function(new_source, inputs="t", outputs="Inertia (kg*m^2)")
+
+
+def _pat_dynamic_product_helper(
+    com_inertia_product, mass, distance_vec_3d, product_term_lambda
+):
+    """Apply the PAT to inertia products, supporting static and dynamic inputs."""
+
+    is_dynamic = (
+        isinstance(com_inertia_product, Function)
+        or isinstance(mass, Function)
+        or isinstance(distance_vec_3d, Function)
+    )
+
+    def get_val(arg, t):
+        return arg(t) if isinstance(arg, Function) else arg
+
+    if not is_dynamic:
+        d_vec = Vector(distance_vec_3d)
+        mass_term = mass * product_term_lambda(d_vec)
+        return com_inertia_product + mass_term
+
+    def new_source(t):
+        d_vec_t = get_val(distance_vec_3d, t)
+        mass_t = get_val(mass, t)
+        inertia_t = get_val(com_inertia_product, t)
+        mass_term = mass_t * product_term_lambda(d_vec_t)
+        return inertia_t + mass_term
+
+    return Function(new_source, inputs="t", outputs="Inertia (kg*m^2)")
+
+
+# --- Public functions for the Parallel Axis Theorem ---
+
+
+def parallel_axis_theorem_I11(com_inertia_moment, mass, distance_vec_3d):
+    """Apply PAT to the I11 inertia term.
+
+    Parameters
+    ----------
+    com_inertia_moment : float or Function
+        Inertia moment relative to the component center of mass.
+    mass : float or Function
+        Mass of the component. If a Function, it must map time to mass.
+    distance_vec_3d : array-like or Function
+        Displacement vector from the component COM to the reference COM.
+
+    Returns
+    -------
+    float or Function
+        Updated I11 value referenced to the new axis.
+    """
+
+    return _pat_dynamic_helper(
+        com_inertia_moment, mass, distance_vec_3d, lambda d_vec: d_vec.y**2 + d_vec.z**2
+    )
+
+
+def parallel_axis_theorem_I22(com_inertia_moment, mass, distance_vec_3d):
+    """Apply PAT to the I22 inertia term.
+
+    Parameters
+    ----------
+    com_inertia_moment : float or Function
+        Inertia moment relative to the component center of mass.
+    mass : float or Function
+        Mass of the component. If a Function, it must map time to mass.
+    distance_vec_3d : array-like or Function
+        Displacement vector from the component COM to the reference COM.
+
+    Returns
+    -------
+    float or Function
+        Updated I22 value referenced to the new axis.
+    """
+
+    return _pat_dynamic_helper(
+        com_inertia_moment, mass, distance_vec_3d, lambda d_vec: d_vec.x**2 + d_vec.z**2
+    )
+
+
+def parallel_axis_theorem_I33(com_inertia_moment, mass, distance_vec_3d):
+    """Apply PAT to the I33 inertia term.
+
+    Parameters
+    ----------
+    com_inertia_moment : float or Function
+        Inertia moment relative to the component center of mass.
+    mass : float or Function
+        Mass of the component. If a Function, it must map time to mass.
+    distance_vec_3d : array-like or Function
+        Displacement vector from the component COM to the reference COM.
+
+    Returns
+    -------
+    float or Function
+        Updated I33 value referenced to the new axis.
+    """
+
+    return _pat_dynamic_helper(
+        com_inertia_moment, mass, distance_vec_3d, lambda d_vec: d_vec.x**2 + d_vec.y**2
+    )
+
+
+def parallel_axis_theorem_I12(com_inertia_product, mass, distance_vec_3d):
+    """Apply PAT to the I12 inertia product.
+
+    Parameters
+    ----------
+    com_inertia_product : float or Function
+        Product of inertia relative to the component center of mass.
+    mass : float or Function
+        Mass of the component. If a Function, it must map time to mass.
+    distance_vec_3d : array-like or Function
+        Displacement vector from the component COM to the reference COM.
+
+    Returns
+    -------
+    float or Function
+        Updated I12 value referenced to the new axis.
+    """
+
+    return _pat_dynamic_product_helper(
+        com_inertia_product, mass, distance_vec_3d, lambda d_vec: d_vec.x * d_vec.y
+    )
+
+
+def parallel_axis_theorem_I13(com_inertia_product, mass, distance_vec_3d):
+    """Apply PAT to the I13 inertia product.
+
+    Parameters
+    ----------
+    com_inertia_product : float or Function
+        Product of inertia relative to the component center of mass.
+    mass : float or Function
+        Mass of the component. If a Function, it must map time to mass.
+    distance_vec_3d : array-like or Function
+        Displacement vector from the component COM to the reference COM.
+
+    Returns
+    -------
+    float or Function
+        Updated I13 value referenced to the new axis.
+    """
+
+    return _pat_dynamic_product_helper(
+        com_inertia_product, mass, distance_vec_3d, lambda d_vec: d_vec.x * d_vec.z
+    )
+
+
+def parallel_axis_theorem_I23(com_inertia_product, mass, distance_vec_3d):
+    """Apply PAT to the I23 inertia product.
+
+    Parameters
+    ----------
+    com_inertia_product : float or Function
+        Product of inertia relative to the component center of mass.
+    mass : float or Function
+        Mass of the component. If a Function, it must map time to mass.
+    distance_vec_3d : array-like or Function
+        Displacement vector from the component COM to the reference COM.
+
+    Returns
+    -------
+    float or Function
+        Updated I23 value referenced to the new axis.
+    """
+
+    return _pat_dynamic_product_helper(
+        com_inertia_product, mass, distance_vec_3d, lambda d_vec: d_vec.y * d_vec.z
+    )
+
+
+__all__ = [
+    "parallel_axis_theorem_I11",
+    "parallel_axis_theorem_I22",
+    "parallel_axis_theorem_I33",
+    "parallel_axis_theorem_I12",
+    "parallel_axis_theorem_I13",
+    "parallel_axis_theorem_I23",
+]

rocketpy/motors/cluster_motor.py

@@ -3,15 +3,15 @@
 import numpy as np
 
 from rocketpy.mathutils.function import Function
-from rocketpy.mathutils.vector_matrix import Vector
-from rocketpy.tools import (
+from rocketpy.mathutils.inertia import (
     parallel_axis_theorem_I11,
     parallel_axis_theorem_I12,
     parallel_axis_theorem_I13,
     parallel_axis_theorem_I22,
     parallel_axis_theorem_I23,
     parallel_axis_theorem_I33,
 )
+from rocketpy.mathutils.vector_matrix import Vector
 
 
 class ClusterMotor:

rocketpy/motors/hybrid_motor.py

@@ -1,16 +1,16 @@
 from functools import cached_property
 
 from ..mathutils.function import Function, funcify_method, reset_funcified_methods
-from ..mathutils.vector_matrix import Vector
-from ..plots.hybrid_motor_plots import _HybridMotorPlots
-from ..tools import (
+from ..mathutils.inertia import (
     parallel_axis_theorem_I11,
     parallel_axis_theorem_I12,
     parallel_axis_theorem_I13,
     parallel_axis_theorem_I22,
     parallel_axis_theorem_I23,
     parallel_axis_theorem_I33,
 )
+from ..mathutils.vector_matrix import Vector
+from ..plots.hybrid_motor_plots import _HybridMotorPlots
 from .motor import Motor
 from .solid_motor import SolidMotor
 

rocketpy/motors/motor.py

@@ -12,18 +12,18 @@
 import requests
 
 from ..mathutils.function import Function, funcify_method
-from ..mathutils.vector_matrix import Matrix, Vector
-from ..plots.motor_plots import _MotorPlots
-from ..prints.motor_prints import _MotorPrints
-from ..tools import (
+from ..mathutils.inertia import (
     parallel_axis_theorem_I11,
     parallel_axis_theorem_I12,
     parallel_axis_theorem_I13,
     parallel_axis_theorem_I22,
     parallel_axis_theorem_I23,
     parallel_axis_theorem_I33,
-    tuple_handler,
 )
+from ..mathutils.vector_matrix import Matrix, Vector
+from ..plots.motor_plots import _MotorPlots
+from ..prints.motor_prints import _MotorPrints
+from ..tools import tuple_handler
 
 # pylint: disable=too-many-public-methods
 # ThrustCurve API cache
@@ -243,18 +243,52 @@ def __init__(
         self.burn_out_time = self.burn_time[1]
 
         # Reshape thrust curve if needed
-        self.reshape_thrust_curve = reshape_thrust_curve
-        if reshape_thrust_curve:
-            self._reshape_thrust_curve(*reshape_thrust_curve)
+        reshape_thrust_curve_input = reshape_thrust_curve
+        if reshape_thrust_curve_input:
+            try:
+                new_burn_time, desired_impulse = reshape_thrust_curve_input
+            except (TypeError, ValueError) as exc:
+                raise TypeError(
+                    "reshape_thrust_curve must be an iterable with two elements:"
+                    " (new_burn_time, total_impulse)."
+                ) from exc
+
+            self.thrust = self.reshape_thrust_curve(
+                self.thrust, new_burn_time, desired_impulse
+            )
 
         # Basic calculations and attributes
         self.burn_duration = self.burn_out_time - self.burn_start_time
         self.total_impulse = self.thrust.integral(
             self.burn_start_time, self.burn_out_time
         )
-        self.max_thrust = self.thrust.max
+
+        # Calculate max_thrust and max_thrust_time
+        try:
+            self.max_thrust = self.thrust.max
+            # Find time of max thrust by evaluating thrust at multiple points
+            if hasattr(self.thrust, "x_array"):
+                max_thrust_index = np.argmax(self.thrust.y_array)
+                self.max_thrust_time = self.thrust.x_array[max_thrust_index]
+            else:
+                # For lambda functions, sample over burn time
+                time_samples = np.linspace(
+                    self.burn_start_time, self.burn_out_time, 1000
+                )
+                thrust_samples = [self.thrust(t) for t in time_samples]
+                max_thrust_index = np.argmax(thrust_samples)
+                self.max_thrust = thrust_samples[max_thrust_index]
+                self.max_thrust_time = time_samples[max_thrust_index]
+        except AttributeError:
+            # If thrust is lambda-based, sample to find max
+            time_samples = np.linspace(self.burn_start_time, self.burn_out_time, 1000)
+            thrust_samples = [self.thrust(t) for t in time_samples]
+            max_thrust_index = np.argmax(thrust_samples)
+            self.max_thrust = thrust_samples[max_thrust_index]
+            self.max_thrust_time = time_samples[max_thrust_index]
 
         self.average_thrust = self.total_impulse / self.burn_duration
+        self.reshape_thrust_curve_request = reshape_thrust_curve_input
 
         # Abstract methods - must be implemented by subclasses
         self._propellant_initial_mass = 0