MNT: point mass motor cleanup

-MNT: removing the parameters not needed for point mass kind of motors

-MNT: removing extra parameter thrust_curve

-MNT: fixing problems with motor class inheritance

Author: aZira371

rocketpy/motors/PointMassMotor.py

@@ -1,121 +1,222 @@
 from functools import cached_property
 import numpy as np
-from ..mathutils.function import Function, funcify_method
-from .motor import Motor
+import csv
+import math 
+from typing import Callable # Import Callable from the typing module
 
-class PointMassMotor(Motor):
+from rocketpy.mathutils.function import Function, funcify_method
+from .motor import Motor 
+
+class PointMassMotor(Motor): 
     """Class representing a motor modeled as a point mass.
+
     Inherits from the Motor class and simplifies the model to a thrust-producing
-    object without detailed structural components."""
+    object without detailed structural components. The total mass of the motor
+    will vary with propellant consumption, similar to a standard motor. However,
+    its inertia components and the center of propellant mass are considered zero
+    and fixed at the motor's reference point, respectively.
+    """
 
     def __init__(
         self,
         thrust_source,
-        dry_mass,
-        thrust_curve=None,
-        propellant_initial_mass=None,
-        propellant_final_mass=None,
-        burn_time=None,
-        center_of_dry_mass_position=0,
-        reshape_thrust_curve=False,
-        interpolation_method="linear",
-        coordinate_system_orientation="nozzle_to_combustion_chamber",
+        dry_mass: float,
+        propellant_initial_mass: float, # Now explicitly required
+        burn_time: float = None,
+        propellant_final_mass: float = None,
+        reshape_thrust_curve: bool = False,
+        interpolation_method: str = "linear",
     ):
         """Initialize the PointMassMotor class.
-        
+
+        This motor simplifies the physical model by considering its mass to be
+        concentrated at a single point, effectively setting all its inertia
+        components to zero. Propellant mass variation and exhaust velocity
+        are still simulated and derived from the thrust and propellant consumption
+        characteristics, similar to the base Motor class.
+
         Parameters
         ----------
-        thrust_source : int, float, callable, string, array, Function
-            Thrust source similar to the Motor class.
+        thrust_source : int, float, callable, str, numpy.ndarray, Function
+            Thrust source. Can be a constant value (int, float), a callable
+            function of time, a path to a CSV file, a NumPy array, or a
+            RocketPy `Function` object.
         dry_mass : float
             Total dry mass of the motor in kg.
-        thrust_curve : Function, np.array, or str (csv file), optional
-            Required if thrust_source is a csv file, Function, or np.array.
-        propellant_initial_mass : float, optional
-            Required if thrust_source is a csv file, Function, or np.array.
+        propellant_initial_mass : float
+            Initial mass of the propellant in kg. This is a required parameter
+            as the point mass motor will still simulate propellant consumption.
+        burn_time : float, optional
+            Total burn time of the motor in seconds. Required if `thrust_source`
+            is a constant value or a callable function, and `propellant_final_mass`
+            is not provided. If `thrust_source` is a CSV, array, or Function,
+            the burn time is derived from it.
         propellant_final_mass : float, optional
-            Required if thrust_source is callable.
-        burn_time : float or tuple of float, optional
-            Required if thrust_source is callable or if a thrust value is given.
-        center_of_dry_mass_position : float, optional
-            Initial position of the motor, default is 0.
-        interpolation_method : string, optional
-            Interpolation method for thrust curve, default is 'linear'.
+            Final mass of the propellant in kg. Required if `thrust_source`
+            is a callable function and `burn_time` is not provided. If not
+            provided, it is calculated by the base Motor class.
+        reshape_thrust_curve : bool, optional
+            Whether to reshape the thrust curve to start at t=0 and end at
+            burn_time. Defaults to False.
+        interpolation_method : str, optional
+            Interpolation method for the thrust curve, if applicable.
+            Defaults to 'linear'.
+
+        Raises
+        ------
+        ValueError
+            If insufficient data is provided for mass flow rate calculation.
+        TypeError
+            If an invalid type is provided for `thrust_source`.
         """
-        if isinstance(thrust_source, (Function, np.ndarray, str)):
-            if thrust_curve is None or propellant_initial_mass is None:
-                raise ValueError("thrust_curve and propellant_initial_mass are required for csv, Function, or np.array inputs.")
-        elif callable(thrust_source):
-            if any(param is None for param in [thrust_curve, propellant_initial_mass, burn_time, propellant_final_mass]):
-                raise ValueError("thrust_curve, propellant_initial_mass, burn_time, and propellant_final_mass are required for callable inputs.")
-        elif isinstance(thrust_source, (int, float)):
-            if any(param is None for param in [thrust_curve, propellant_initial_mass, burn_time]):
-                raise ValueError("thrust_curve, propellant_initial_mass, and burn_time are required when a thrust value is given.")
+        # Input validation: Ensure critical parameters for mass flow are present
+        if isinstance(thrust_source, (int, float, Callable)):
+            if propellant_initial_mass is None:
+                raise ValueError(
+                    "For constant or callable thrust, 'propellant_initial_mass' is required."
+                )
+            if burn_time is None and propellant_final_mass is None:
+                raise ValueError(
+                    "For constant or callable thrust, either 'burn_time' or "
+                    "'propellant_final_mass' must be provided."
+                )
 
-        self._propellant_initial_mass = propellant_initial_mass
+        elif isinstance(thrust_source, (Function, np.ndarray, str)):
+            if propellant_initial_mass is None:
+                raise ValueError(
+                    "For thrust from a Function, NumPy array, or CSV, 'propellant_initial_mass' is required."
+                )
+        else:
+             raise TypeError(
+                "Invalid 'thrust_source' type. Must be int, float, callable, str, numpy.ndarray, or Function."
+            )
+
+        self.propellant_initial_mass = propellant_initial_mass
+        self.propellant_final_mass = propellant_final_mass
+
+        # Call the superclass constructor, passing center_of_dry_mass_position=0
         super().__init__(
             thrust_source=thrust_source,
-            dry_inertia=(0, 0, 0),
-            nozzle_radius=0,
-        center_of_dry_mass_position=center_of_dry_mass_position,
+            dry_inertia=(0, 0, 0), # Inertia is zero for a point mass
+            nozzle_radius=0, # Nozzle radius is irrelevant for a point mass model
+            center_of_dry_mass_position=0, # Pass 0 directly to the superclass
             dry_mass=dry_mass,
-            nozzle_position=0,
+            nozzle_position=0, # Nozzle is at the motor's origin
             burn_time=burn_time,
-            reshape_thrust_curve=reshape_thrust_curve,
+            reshape_thrust_curve=reshape_thrust_curve, # Pass the user-provided value
             interpolation_method=interpolation_method,
-            coordinate_system_orientation=coordinate_system_orientation,
-        )       
-    @funcify_method("Time (s)", "Thrust (N)")
-    def thrust(self):
-        """Returns the thrust of the motor as a function of time."""
-        return self.thrust_source
-
-    @funcify_method("Time (s)", "Acceleration (m/s^2)")
-    def total_mass(self):
-        """Returns the constant total mass of the point mass motor."""
-        return self.dry_mass
-
-    @funcify_method("Time (s)", "Acceleration (m/s^2)")
-    def acceleration(self):
-        """Computes the acceleration of the motor as thrust divided by mass."""
-        return self.thrust() / self.total_mass
+            coordinate_system_orientation="nozzle_to_combustion_chamber", # Standard orientation
+        )
 
-    @funcify_method("Time (s)", "Propellant Mass (kg)")
-    def center_of_propellant_mass(self):
-        return 0
+    # Removed the thrust method. It will now be inherited directly from the Motor base class,
+    # which already correctly handles the conversion of thrust_source to a Function
+    # and exposes it as a cached property.
+
+    # Removed the total_mass override. The base Motor class's total_mass property
+    # will now correctly calculate dry_mass + propellant_mass(t), which is the desired
+    # varying mass behavior for the point mass motor.
 
-    @funcify_method("Time (s)", "Exhaust Velocity (m/s)")
-    def exhaust_velocity(self):
-        return 2000  # m/s, estimated value
+    # Removed the center_of_dry_mass_position override. It is now passed directly
+    # to the super().__init__ as 0.
 
+    @cached_property
     @funcify_method("Time (s)", "Propellant Mass (kg)")
-    def propellant_initial_mass(self):
-        return self._propellant_initial_mass
+    def center_of_propellant_mass(self) -> Function:
+        """Returns the position of the center of mass of the propellant.
+
+        For a point mass motor, the propellant's center of mass is considered
+        to be at the origin (0) of the motor's coordinate system.
 
-    @property
-    def is_point_mass(self):
-        return True
-    
+        Returns
+        -------
+        Function
+            A Function object representing the center of propellant mass (always 0).
+        """
+        return 0
+
+    # Removed exhaust_velocity override. It will now be inherited from the Motor base class,
+    # which calculates it dynamically based on thrust and mass_flow_rate.
+
+    @cached_property
     @funcify_method("Time (s)", "Inertia (kg·m²)")
-    def propellant_I_11(self):
-          return 0
+    def propellant_I_11(self) -> Function:
+        """Returns the propellant moment of inertia around the x-axis.
 
+        For a point mass motor, this is always zero.
+
+        Returns
+        -------
+        Function
+            A Function object representing zero propellant inertia.
+        """
+        return 0
+
+    @cached_property
     @funcify_method("Time (s)", "Inertia (kg·m²)")
-    def propellant_I_12(self):
+    def propellant_I_12(self) -> Function:
+        """Returns the propellant product of inertia I_xy.
+
+        For a point mass motor, this is always zero.
+
+        Returns
+        -------
+        Function
+            A Function object representing zero propellant inertia.
+        """
         return 0
 
+    @cached_property
     @funcify_method("Time (s)", "Inertia (kg·m²)")
-    def propellant_I_13(self):
+    def propellant_I_13(self) -> Function:
+        """Returns the propellant product of inertia I_xz.
+
+        For a point mass motor, this is always zero.
+
+        Returns
+        -------
+        Function
+            A Function object representing zero propellant inertia.
+        """
         return 0
 
+    @cached_property
     @funcify_method("Time (s)", "Inertia (kg·m²)")
-    def propellant_I_22(self):
+    def propellant_I_22(self) -> Function:
+        """Returns the propellant moment of inertia around the y-axis.
+
+        For a point mass motor, this is always zero.
+
+        Returns
+        -------
+        Function
+            A Function object representing zero propellant inertia.
+        """
         return 0
 
+    @cached_property
     @funcify_method("Time (s)", "Inertia (kg·m²)")
-    def propellant_I_23(self):
+    def propellant_I_23(self) -> Function:
+        """Returns the propellant product of inertia I_yz.
+
+        For a point mass motor, this is always zero.
+
+        Returns
+        -------
+        Function
+            A Function object representing zero propellant inertia.
+        """
         return 0
 
+    @cached_property
     @funcify_method("Time (s)", "Inertia (kg·m²)")
-    def propellant_I_33(self):
+    def propellant_I_33(self) -> Function:
+        """Returns the propellant moment of inertia around the z-axis.
+
+        For a point mass motor, this is always zero.
+
+        Returns
+        -------
+        Function
+            A Function object representing zero propellant inertia.
+        """
         return 0