ENH: Introduce the StochasticAirBrakes class

CHANGELOG.md

@@ -34,6 +34,8 @@ Attention: The newest changes should be on top -->
 
 - ENH: Parallel mode for monte-carlo simulations 2 [#768](https://github.com/RocketPy-Team/RocketPy/pull/768)
 - DOC: ASTRA Flight Example [#770](https://github.com/RocketPy-Team/RocketPy/pull/770)
+- ENH: Add Eccentricity to Stochastic Simulations [#792](https://github.com/RocketPy-Team/RocketPy/pull/792)
+- ENH: Introduce the StochasticAirBrakes class [#785](https://github.com/RocketPy-Team/RocketPy/pull/785)
 
 ### Changed
 
@@ -46,6 +48,7 @@ Attention: The newest changes should be on top -->
 - BUG: update flight simulation logic to include burn start time [#778](https://github.com/RocketPy-Team/RocketPy/pull/778)
 - BUG: fixes get_instance_attributes for Flight objects containing a Rocket object without rail buttons [#786](https://github.com/RocketPy-Team/RocketPy/pull/786)
 - BUG: fixed AGL altitude print for parachutes with lag [#788](https://github.com/RocketPy-Team/RocketPy/pull/788)
+- BUG: fix the wind velocity factors usage and better visualization of uniform distributions in Stochastic Classes [#783](https://github.com/RocketPy-Team/RocketPy/pull/783)
 
 
 ## [v1.8.0] - 2025-01-20

rocketpy/__init__.py

@@ -44,6 +44,7 @@
 from .sensors import Accelerometer, Barometer, GnssReceiver, Gyroscope
 from .simulation import Flight, MonteCarlo
 from .stochastic import (
+    StochasticAirBrakes,
     StochasticEllipticalFins,
     StochasticEnvironment,
     StochasticFlight,

rocketpy/mathutils/function.py

@@ -2219,10 +2219,10 @@
         """
         return other + (-self)
 
-    def __mul__(self, other):
+    def __mul__(self, other):  # pylint: disable=too-many-statements
         """Multiplies a Function object and returns a new Function object
         which gives the result of the multiplication. Only implemented for 1D
-        domains.
+        and 2D domains.
 
         Parameters
         ----------
@@ -2238,7 +2238,7 @@
         Returns
         -------
         result : Function
-            A Function object which gives the result of self(x)*other(x).
+            A Function object which gives the result of self(x)*other(x) or self(x,y)*other(x,y).
         """
         self_source_is_array = isinstance(self.source, np.ndarray)
         other_source_is_array = (
@@ -2250,37 +2250,76 @@
         interp = self.__interpolation__
         extrap = self.__extrapolation__
 
-        if (
-            self_source_is_array
-            and other_source_is_array
-            and np.array_equal(self.x_array, other.x_array)
-        ):
-            source = np.column_stack((self.x_array, self.y_array * other.y_array))
-            outputs = f"({self.__outputs__[0]}*{other.__outputs__[0]})"
-            return Function(source, inputs, outputs, interp, extrap)
-        elif isinstance(other, NUMERICAL_TYPES) or self.__is_single_element_array(
-            other
-        ):
-            if not self_source_is_array:
-                return Function(lambda x: (self.get_value_opt(x) * other), inputs)
-            source = np.column_stack((self.x_array, np.multiply(self.y_array, other)))
-            outputs = f"({self.__outputs__[0]}*{other})"
-            return Function(
-                source,
-                inputs,
-                outputs,
-                interp,
-                extrap,
-            )
-        elif callable(other):
-            return Function(lambda x: (self.get_value_opt(x) * other(x)), inputs)
-        else:
-            raise TypeError("Unsupported type for multiplication")
+        if self.__dom_dim__ == 1:
+            if (
+                self_source_is_array
+                and other_source_is_array
+                and np.array_equal(self.x_array, other.x_array)
+            ):
+                source = np.column_stack((self.x_array, self.y_array * other.y_array))
+                outputs = f"({self.__outputs__[0]}*{other.__outputs__[0]})"
+                return Function(source, inputs, outputs, interp, extrap)
+            elif isinstance(other, NUMERICAL_TYPES) or self.__is_single_element_array(
+                other
+            ):
+                if not self_source_is_array:
+                    return Function(lambda x: (self.get_value_opt(x) * other), inputs)
+                source = np.column_stack(
+                    (self.x_array, np.multiply(self.y_array, other))
+                )
+                outputs = f"({self.__outputs__[0]}*{other})"
+                return Function(
+                    source,
+                    inputs,
+                    outputs,
+                    interp,
+                    extrap,
+                )
+            elif callable(other):
+                return Function(lambda x: (self.get_value_opt(x) * other(x)), inputs)
+            else:
+                raise TypeError("Unsupported type for multiplication")
+        elif self.__dom_dim__ == 2:
+            if (
+                self_source_is_array
+                and other_source_is_array
+                and np.array_equal(self.x_array, other.x_array)
+                and np.array_equal(self.y_array, other.y_array)
+            ):
+                source = np.column_stack(
+                    (self.x_array, self.y_array, self.z_array * other.z_array)
+                )
+                outputs = f"({self.__outputs__[0]}*{other.__outputs__[0]})"
+                return Function(source, inputs, outputs, interp, extrap)
+            elif isinstance(other, NUMERICAL_TYPES) or self.__is_single_element_array(
+                other
+            ):
+                if not self_source_is_array:
+                    return Function(
+                        lambda x, y: (self.get_value_opt(x, y) * other), inputs
+                    )
+                source = np.column_stack(
+                    (self.x_array, self.y_array, np.multiply(self.z_array, other))
+                )
+                outputs = f"({self.__outputs__[0]}*{other})"
+                return Function(
+                    source,
+                    inputs,
+                    outputs,
+                    interp,
+                    extrap,
+                )
+            elif callable(other):
+                return Function(
+                    lambda x, y: (self.get_value_opt(x, y) * other(x)), inputs
+                )
+            else:
+                raise TypeError("Unsupported type for multiplication")
 
     def __rmul__(self, other):
         """Multiplies 'other' by a Function object and returns a new Function
         object which gives the result of the multiplication. Only implemented for
-        1D domains.
+        1D and 2D domains.
 
         Parameters
         ----------
@@ -2290,7 +2329,7 @@
         Returns
         -------
         result : Function
-            A Function object which gives the result of other(x)*self(x).
+            A Function object which gives the result of other(x,y)*self(x,y).
         """
         return self * other
 

rocketpy/simulation/monte_carlo.py

@@ -458,6 +458,7 @@ def __run_single_simulation(self):
             heading=self.flight._randomize_heading(),
             initial_solution=self.flight.initial_solution,
             terminate_on_apogee=self.flight.terminate_on_apogee,
+            time_overshoot=self.flight.time_overshoot,
         )
 
     def __evaluate_flight_inputs(self, sim_idx):

rocketpy/stochastic/__init__.py

@@ -6,6 +6,7 @@
 """
 
 from .stochastic_aero_surfaces import (
+    StochasticAirBrakes,
     StochasticEllipticalFins,
     StochasticNoseCone,
     StochasticRailButtons,

rocketpy/stochastic/stochastic_aero_surfaces.py

@@ -9,6 +9,7 @@
     RailButtons,
     Tail,
     TrapezoidalFins,
+    AirBrakes,
 )
 
 from .stochastic_model import StochasticModel
@@ -432,3 +433,114 @@
         """
         generated_dict = next(self.dict_generator())
         return RailButtons(**generated_dict)
+
+
+class StochasticAirBrakes(StochasticModel):
+    """A Stochastic Air Brakes class that inherits from StochasticModel.
+
+    See Also
+    --------
+    :ref:`stochastic_model` and
+    :class:`AirBrakes <rocketpy.AirBrakes>`
+
+    Attributes
+    ----------
+    object : AirBrakes
+        AirBrakes object to be used for validation.
+    drag_coefficient_curve : list, str
+        The drag coefficient curve of the air brakes can account for
+        either the air brakes' drag alone or the combined drag of both
+        the rocket and the air brakes.
+    drag_coefficient_curve_factor : tuple, list, int, float
+        The drag curve factor of the air brakes. This value scales the
+        drag coefficient curve to introduce stochastic variability.
+    reference_area : tuple, list, int, float
+        Reference area used to non-dimensionalize the drag coefficients.
+    clamp : bool
+        If True, the simulation will clamp the deployment level to 0 or 1 if
+        the deployment level is out of bounds. If False, the simulation will
+        not clamp the deployment level and will instead raise a warning if
+        the deployment level is out of bounds.
+    override_rocket_drag : bool
+        If False, the air brakes drag coefficient will be added to the
+        rocket's power off drag coefficient curve. If True, during the
+        simulation, the rocket's power off drag will be ignored and the air
+        brakes drag coefficient will be used for the entire rocket instead.
+    deployment_level : tuple, list, int, float
+        Initial deployment level, ranging from 0 to 1.
+    name : list[str]
+        List with the air brakes object name. This attribute can't be randomized.
+    """
+
+    def __init__(
+        self,
+        air_brakes,
+        drag_coefficient_curve=None,
+        drag_coefficient_curve_factor=(1, 0),
+        reference_area=None,
+        clamp=None,
+        override_rocket_drag=None,
+        deployment_level=(0, 0),
+    ):
+        """Initializes the Stochastic AirBrakes class.
+
+        See Also
+        --------
+        :ref:`stochastic_model`
+
+        Parameters
+        ----------
+        air_brakes : AirBrakes
+            AirBrakes object to be used for validation.
+        drag_coefficient_curve : list, str, optional
+            The drag coefficient curve of the air brakes can account for
+            either the air brakes' drag alone or the combined drag of both
+            the rocket and the air brakes.
+        drag_coefficient_curve_factor : tuple, list, int, float, optional
+            The drag curve factor of the air brakes. This value scales the
+            drag coefficient curve to introduce stochastic variability.
+        reference_area : tuple, list, int, float, optional
+            Reference area used to non-dimensionalize the drag coefficients.
+        clamp : bool, optional
+            If True, the simulation will clamp the deployment level to 0 or 1 if
+            the deployment level is out of bounds. If False, the simulation will
+            not clamp the deployment level and will instead raise a warning if
+            the deployment level is out of bounds.
+        override_rocket_drag : bool, optional
+            If False, the air brakes drag coefficient will be added to the
+            rocket's power off drag coefficient curve. If True, during the
+            simulation, the rocket's power off drag will be ignored and the air
+            brakes drag coefficient will be used for the entire rocket instead.
+        deployment_level : tuple, list, int, float, optional
+            Initial deployment level, ranging from 0 to 1.
+        """
+        super().__init__(
+            air_brakes,
+            drag_coefficient_curve=drag_coefficient_curve,
+            drag_coefficient_curve_factor=drag_coefficient_curve_factor,
+            reference_area=reference_area,
+            clamp=clamp,
+            override_rocket_drag=override_rocket_drag,
+            deployment_level=deployment_level,
+            name=None,
+        )
+
+    def create_object(self):
+        """Creates and returns an AirBrakes object from the randomly generated
+        input arguments.
+
+        Returns
+        -------
+        air_brake : AirBrakes
+            AirBrakes object with the randomly generated input arguments.
+        """
+        generated_dict = next(self.dict_generator())
+        air_brakes = AirBrakes(
+            drag_coefficient_curve=generated_dict["drag_coefficient_curve"],
+            reference_area=generated_dict["reference_area"],
+            clamp=generated_dict["clamp"],
+            override_rocket_drag=generated_dict["override_rocket_drag"],
+            deployment_level=generated_dict["deployment_level"],
+        )
+        air_brakes.drag_coefficient *= generated_dict["drag_coefficient_curve_factor"]
+        return air_brakes

rocketpy/stochastic/stochastic_flight.py

@@ -29,6 +29,9 @@
     terminate_on_apogee : bool
         Whether or not the flight should terminate on apogee. This attribute
         can not be randomized.
+    time_overshoot : bool
+        If False, the simulation will run at the time step defined by the controller
+        sampling rate. Be aware that this will make the simulation run much slower.
     """
 
     def __init__(
@@ -39,6 +42,7 @@
         heading=None,
         initial_solution=None,
         terminate_on_apogee=None,
+        time_overshoot=None,
     ):
         """Initializes the Stochastic Flight class.
 
@@ -63,11 +67,17 @@
         terminate_on_apogee : bool, optional
             Whether or not the flight should terminate on apogee. This attribute
             can not be randomized.
+        time_overshoot : bool
+            If False, the simulation will run at the time step defined by the controller
+            sampling rate. Be aware that this will make the simulation run much slower.
         """
         if terminate_on_apogee is not None:
             assert isinstance(terminate_on_apogee, bool), (
                 "`terminate_on_apogee` must be a boolean"
             )
+        if time_overshoot is not None:
+            if not isinstance(time_overshoot, bool):
+                raise TypeError("`time_overshoot` must be a boolean")
         super().__init__(
             flight,
             rail_length=rail_length,
@@ -77,6 +87,7 @@
 
         self.initial_solution = initial_solution
         self.terminate_on_apogee = terminate_on_apogee
+        self.time_overshoot = time_overshoot
 
     def _validate_initial_solution(self, initial_solution):
         if initial_solution is not None:
@@ -128,4 +139,5 @@
             heading=generated_dict["heading"],
             initial_solution=self.initial_solution,
             terminate_on_apogee=self.terminate_on_apogee,
+            time_overshoot=self.time_overshoot,
         )