Merge branch 'develop' into rel/v1.1.0

Author: Gui-FernandesBR

.pylintrc

@@ -185,16 +185,18 @@ function-naming-style=snake_case
 #function-rgx=
 
 # Good variable names which should always be accepted, separated by a comma.
-good-names=i,
-           j,
-           k,
-           ex,
-           Run,
-           _
+good-names=FlightPhases,
+           WindroseAxes,
+
 
 # Good variable names regexes, separated by a comma. If names match any regex,
 # they will always be accepted
-good-names-rgxs=
+good-names-rgxs= ^[a-z][0-9]?$,  # Single lowercase characters, possibly followed by a single digit
+                 ^[A-Z][0-9]{0,2}$,  # Single uppercase characters, possibly followed by one or two digits
+                 ^[A-Z]+_\d+(_dot)?$,  # Uppercase characters followed by underscore and digits, optionally followed by _dot
+                 ^(dry_|propellant_)[A-Z]+_\d+$,  # Variables starting with 'dry_' or 'propellant_', followed by uppercase characters, underscore, and digits
+                 ^[a-z]+_ISA$,  # Lowercase words ending with '_ISA'
+                 ^plot(1D|2D)$,  # Variables starting with 'plot' followed by '1D' or '2D'
 
 # Include a hint for the correct naming format with invalid-name.
 include-naming-hint=no

rocketpy/mathutils/function.py

@@ -4,8 +4,8 @@
 carefully as it may impact all the rest of the project.
 """
 import warnings
-from inspect import signature
 from collections.abc import Iterable
+from inspect import signature
 from pathlib import Path
 
 import matplotlib.pyplot as plt
@@ -222,7 +222,7 @@ def source_function(_):
                 source = source[source[:, 0].argsort()]
 
                 self.x_array = source[:, 0]
-                self.xinitial, self.xfinal = self.x_array[0], self.x_array[-1]
+                self.x_initial, self.x_final = self.x_array[0], self.x_array[-1]
 
                 self.y_array = source[:, 1]
                 self.y_initial, self.y_final = self.y_array[0], self.y_array[-1]
@@ -241,7 +241,7 @@ def source_function(_):
             # Do things if function is multivariate
             else:
                 self.x_array = source[:, 0]
-                self.xinitial, self.xfinal = self.x_array[0], self.x_array[-1]
+                self.x_initial, self.x_final = self.x_array[0], self.x_array[-1]
 
                 self.y_array = source[:, 1]
                 self.y_initial, self.y_final = self.y_array[0], self.y_array[-1]
@@ -251,30 +251,6 @@ def source_function(_):
 
                 # Finally set data source as source
                 self.source = source
-
-                # Update extrapolation method
-                if (
-                    self.__extrapolation__ is None
-                    or self.__extrapolation__ == "natural"
-                ):
-                    self.set_extrapolation("natural")
-                else:
-                    raise ValueError(
-                        "Multidimensional datasets only support natural extrapolation."
-                    )
-
-                # Set default multidimensional interpolation if it hasn't
-                if (
-                    self.__interpolation__ is None
-                    or self.__interpolation__ == "shepard"
-                ):
-                    self.set_interpolation("shepard")
-                else:
-                    raise ValueError(
-                        "Multidimensional datasets only support shepard interpolation."
-                    )
-
-        # Return self
         return self
 
     @cached_property
@@ -363,7 +339,7 @@ def set_get_value_opt(self):
         # Retrieve general info
         x_data = self.x_array
         y_data = self.y_array
-        x_min, x_max = self.xinitial, self.xfinal
+        x_min, x_max = self.x_initial, self.x_final
         if self.__extrapolation__ == "zero":
             extrapolation = 0  # Extrapolation is zero
         elif self.__extrapolation__ == "natural":
@@ -557,6 +533,7 @@ def set_discrete(
             zs = np.array(self.get_value(mesh))
             self.set_source(np.concatenate(([xs], [ys], [zs])).transpose())
             self.__interpolation__ = "shepard"
+            self.__extrapolation__ = "natural"
         return self
 
     def set_discrete_based_on_model(
@@ -888,7 +865,7 @@ def get_value(self, *args):
             x = np.array(args[0])
             x_data = self.x_array
             y_data = self.y_array
-            x_min, x_max = self.xinitial, self.xfinal
+            x_min, x_max = self.x_initial, self.x_final
             coeffs = self.__polynomial_coefficients__
             matrix = np.zeros((len(args[0]), coeffs.shape[0]))
             for i in range(coeffs.shape[0]):
@@ -909,7 +886,7 @@ def get_value(self, *args):
             x_data = self.x_array
             y_data = self.y_array
             x_intervals = np.searchsorted(x_data, x)
-            x_min, x_max = self.xinitial, self.xfinal
+            x_min, x_max = self.x_initial, self.x_final
             if self.__interpolation__ == "spline":
                 coeffs = self.__spline_coefficients__
                 for i, _ in enumerate(x):
@@ -1229,7 +1206,7 @@ def plot_1d(
         else:
             # Determine boundaries
             x_data = self.x_array
-            x_min, x_max = self.xinitial, self.xfinal
+            x_min, x_max = self.x_initial, self.x_final
             lower = x_min if lower is None else lower
             upper = x_max if upper is None else upper
             # Plot data points if force_data = True
@@ -1356,7 +1333,7 @@ def plot_2d(
             mesh_x.shape
         )
         z_min, z_max = z.min(), z.max()
-        color_map = plt.cm.get_cmap(cmap)
+        color_map = plt.colormaps[cmap]
         norm = plt.Normalize(z_min, z_max)
 
         # Plot function
@@ -1530,7 +1507,7 @@ def __interpolate_polynomial__(self):
         y = self.y_array
         # Check if interpolation requires large numbers
         if np.amax(x) ** degree > 1e308:
-            print(
+            warnings.warn(
                 "Polynomial interpolation of too many points can't be done."
                 " Once the degree is too high, numbers get too large."
                 " The process becomes inefficient. Using spline instead."
@@ -2648,7 +2625,7 @@ def find_input(self, val, start, tol=1e-4):
             The value of the input which gives the output closest to val.
         """
         return optimize.root(
-            lambda x: self.get_value(x) - val,
+            lambda x: self.get_value(x)[0] - val,
             start,
             tol=tol,
         ).x[0]
@@ -2738,10 +2715,10 @@ def compose(self, func, extrapolate=False):
         if isinstance(self.source, np.ndarray) and isinstance(func.source, np.ndarray):
             # Perform bounds check for composition
             if not extrapolate:
-                if func.min < self.xinitial and func.max > self.xfinal:
+                if func.min < self.x_initial and func.max > self.x_final:
                     raise ValueError(
                         f"Input Function image {func.min, func.max} must be within "
-                        f"the domain of the Function {self.xinitial, self.xfinal}."
+                        f"the domain of the Function {self.x_initial, self.x_final}."
                     )
 
             return Function(
@@ -2763,10 +2740,10 @@ def compose(self, func, extrapolate=False):
     @staticmethod
     def _check_user_input(
         source,
-        inputs,
-        outputs,
-        interpolation,
-        extrapolation,
+        inputs=None,
+        outputs=None,
+        interpolation=None,
+        extrapolation=None,
     ):
         """
         Validates and processes the user input parameters for creating or
@@ -2857,30 +2834,55 @@ def _check_user_input(
             source_dim = source.shape[1]
 
             # check interpolation and extrapolation
-            if source_dim > 2:
+
+            ## single dimension
+            if source_dim == 2:
+                # possible interpolation values: llinear, polynomial, akima and spline
+                if interpolation is None:
+                    interpolation = "spline"
+                elif interpolation.lower() not in [
+                    "spline",
+                    "linear",
+                    "polynomial",
+                    "akima",
+                ]:
+                    warnings.warn(
+                        "Interpolation method for single dimensional functions was "
+                        + f"set to 'spline', the {interpolation} method is not supported."
+                    )
+                    interpolation = "spline"
+
+                # possible extrapolation values: constant, natural, zero
+                if extrapolation is None:
+                    extrapolation = "constant"
+                elif extrapolation.lower() not in ["constant", "natural", "zero"]:
+                    warnings.warn(
+                        "Extrapolation method for single dimensional functions was "
+                        + f"set to 'constant', the {extrapolation} method is not supported."
+                    )
+                    extrapolation = "constant"
+
+            ## multiple dimensions
+            elif source_dim > 2:
                 # check for inputs and outputs
                 if inputs == ["Scalar"]:
                     inputs = [f"Input {i+1}" for i in range(source_dim - 1)]
-                    warnings.warn(
-                        f"Inputs not set, defaulting to {inputs} for "
-                        + "multidimensional functions.",
-                    )
 
                 if interpolation not in [None, "shepard"]:
-                    interpolation = "shepard"
                     warnings.warn(
                         (
-                            "Interpolation method for multidimensional functions is set"
-                            "to 'shepard', currently other methods are not supported."
+                            "Interpolation method for multidimensional functions was"
+                            "set to 'shepard', other methods are not supported yet."
                         ),
                     )
+                interpolation = "shepard"
 
-                if extrapolation is None:
-                    extrapolation = "natural"
+                if extrapolation not in [None, "natural"]:
                     warnings.warn(
-                        "Extrapolation not set, defaulting to 'natural' "
-                        + "for multidimensional functions.",
+                        "Extrapolation method for multidimensional functions was set"
+                        "to 'natural', other methods are not supported yet."
                     )
+                extrapolation = "natural"
 
             # check input dimensions
             in_out_dim = len(inputs) + len(outputs)
@@ -2889,21 +2891,6 @@ def _check_user_input(
                     "Source dimension ({source_dim}) does not match input "
                     + f"and output dimension ({in_out_dim})."
                 )
-
-        # if function, check for inputs and outputs
-        if isinstance(source, Function):
-            # check inputs
-            if inputs is not None and inputs != source.get_inputs():
-                warnings.warn(
-                    f"Inputs do not match source inputs, setting inputs to {inputs}.",
-                )
-
-            # check outputs
-            if outputs is not None and outputs != source.get_outputs():
-                warnings.warn(
-                    f"Outputs do not match source outputs, setting outputs to {outputs}.",
-                )
-
         return inputs, outputs, interpolation, extrapolation
 
 
@@ -2937,7 +2924,7 @@ def __new__(
         outputs: list of strings
             A list of strings that represent the outputs of the function.
         interpolation: str
-            The type of interpolation to use. The default value is 'akima'.
+            The type of interpolation to use. The default value is 'spline'.
         extrapolation: str
             The type of extrapolation to use. The default value is None.
         datapoints: int
@@ -3123,13 +3110,6 @@ def source_function(*_):
 
                     source = source_function
                     val = Function(source, *args, **kwargs)
-                except Exception as exc:
-                    # TODO: Raising too general exception Pylint W0719
-                    raise Exception(
-                        "Could not create Function object from method "
-                        f"{self.func.__name__}."
-                    ) from exc
-
                 # pylint: disable=W0201
                 val.__doc__ = self.__doc__
                 val.__cached__ = True

rocketpy/motors/liquid_motor.py

@@ -1,4 +1,13 @@
-from ..mathutils.function import funcify_method, reset_funcified_methods
+import warnings
+
+import numpy as np
+
+from rocketpy.mathutils.function import (
+    Function,
+    funcify_method,
+    reset_funcified_methods,
+)
+
 from ..plots.liquid_motor_plots import _LiquidMotorPlots
 from ..prints.liquid_motor_prints import _LiquidMotorPrints
 from .motor import Motor
@@ -264,7 +273,18 @@ def exhaust_velocity(self):
         mass flow rate. Therefore, this will vary with time if the mass flow
         rate varies with time.
         """
-        return self.thrust / (-1 * self.mass_flow_rate)
+        times, thrusts = self.thrust.source[:, 0], self.thrust.source[:, 1]
+        mass_flow_rates = self.mass_flow_rate(times)
+
+        # Compute exhaust velocity only for non-zero mass flow rates
+        valid_indices = mass_flow_rates != 0
+        valid_times = times[valid_indices]
+        valid_thrusts = thrusts[valid_indices]
+        valid_mass_flow_rates = mass_flow_rates[valid_indices]
+
+        ext_vel = -valid_thrusts / valid_mass_flow_rates
+
+        return np.column_stack([valid_times, ext_vel])
 
     @funcify_method("Time (s)", "Propellant Mass (kg)")
     def propellant_mass(self):

rocketpy/plots/rocket_plots.py

@@ -76,7 +76,7 @@ def stability_margin(self):
         None
         """
 
-        self.rocket.stability_margin.plot2D(
+        self.rocket.stability_margin.plot_2d(
             lower=0,
             upper=[2, self.rocket.motor.burn_out_time],  # Mach 2 and burnout
             samples=[20, 20],

tests/test_flight.py

@@ -147,14 +147,19 @@ def test_initial_solution(mock_show, example_env, calisto_robust):
 def test_get_solution_at_time(flight_calisto):
     """Test the get_solution_at_time method of the Flight class. This test
     simply calls the method at the initial and final time and checks if the
-    returned values are correct.
+    returned values are correct. Also, checking for valid return instance.
 
     Parameters
     ----------
     flight_calisto : rocketpy.Flight
         Flight object to be tested. See the conftest.py file for more info
         regarding this pytest fixture.
     """
+    assert isinstance(flight_calisto.get_solution_at_time(0), np.ndarray)
+    assert isinstance(
+        flight_calisto.get_solution_at_time(flight_calisto.t_final), np.ndarray
+    )
+
     assert np.allclose(
         flight_calisto.get_solution_at_time(0),
         np.array([0, 0, 0, 0, 0, 0, 0, 0.99904822, -0.04361939, 0, 0, 0, 0, 0]),
@@ -576,7 +581,7 @@ def test_lat_lon_conversion_from_origin(mock_show, example_env, calisto_robust):
     ],
 )
 def test_rail_length(calisto_robust, example_env, rail_length, out_of_rail_time):
-    """Test the rail length parameter of the Flight class. This test simply
+    """Tests the rail length parameter of the Flight class. This test simply
     simulate the flight using different rail lengths and checks if the expected
     out of rail altitude is achieved. Four different rail lengths are
     tested: 0.001, 1, 10, and 100000 meters. This provides a good test range.