Run ruff format on modified files

Co-authored-by: Gui-FernandesBR <[email protected]>

Author: Copilot

rocketpy/mathutils/function.py

@@ -455,15 +455,18 @@ def rbf_interpolation(x, x_min, x_max, x_data, y_data, coeffs):  # pylint: disab
             # For grid interpolation, the actual interpolator is stored separately
             # This function is a placeholder that should not be called directly
             # since __get_value_opt_grid is used instead
-            if hasattr(self, '_grid_interpolator'):
+            if hasattr(self, "_grid_interpolator"):
+
                 def grid_interpolation(x, x_min, x_max, x_data, y_data, coeffs):  # pylint: disable=unused-argument
                     return self._grid_interpolator(x)
+
                 self._interpolation_func = grid_interpolation
             else:
                 # Fallback to shepard if grid interpolator not available
                 warnings.warn(
                     "Grid interpolator not found, falling back to shepard interpolation"
                 )
+
                 def shepard_fallback(x, x_min, x_max, x_data, y_data, _):
                     # pylint: disable=unused-argument
                     arg_qty, arg_dim = x.shape
@@ -480,6 +483,7 @@ def shepard_fallback(x, x_min, x_max, x_data, y_data, _):
                     result[valid_indexes] = numerator_sum / denominator_sum
                     result[~valid_indexes] = y_data[zero_distances[1]]
                     return result
+
                 self._interpolation_func = shepard_fallback
 
         else:
@@ -683,22 +687,22 @@ def __get_value_opt_grid(self, *args):
             Value of the Function at the specified points.
         """
         # Check if we have the grid interpolator
-        if not hasattr(self, '_grid_interpolator'):
+        if not hasattr(self, "_grid_interpolator"):
             raise RuntimeError(
                 "Grid interpolator not initialized. Use from_grid() to create "
                 "a Function with grid interpolation."
             )
-        
+
         # Convert args to appropriate format for RegularGridInterpolator
         # RegularGridInterpolator expects points as (N, ndim) array
         if len(args) != self.__dom_dim__:
             raise ValueError(
                 f"Expected {self.__dom_dim__} arguments but got {len(args)}"
             )
-        
+
         # Handle single point evaluation
         point = np.array(args).reshape(1, -1)
-        
+
         # Handle extrapolation based on the extrapolation setting
         if self.__extrapolation__ == "constant":
             # Clamp point to grid boundaries for constant extrapolation
@@ -719,11 +723,11 @@ def __get_value_opt_grid(self, *args):
         else:
             # Natural or other extrapolation - use interpolator directly
             result = self._grid_interpolator(point)
-        
+
         # Return scalar for single evaluation
         if result.size == 1:
             return float(result[0])
-        
+
         return result
 
     def __determine_1d_domain_bounds(self, lower, upper):
@@ -4042,10 +4046,18 @@ def to_dict(self, **kwargs):  # pylint: disable=unused-argument
         }
 
     @classmethod
-    def from_grid(cls, grid_data, axes, inputs=None, outputs=None, 
-                  interpolation="linear_grid", extrapolation="constant", **kwargs):
+    def from_grid(
+        cls,
+        grid_data,
+        axes,
+        inputs=None,
+        outputs=None,
+        interpolation="linear_grid",
+        extrapolation="constant",
+        **kwargs,
+    ):
         """Creates a Function from N-dimensional grid data.
-        
+
         This method is designed for structured grid data, such as CFD simulation
         results where values are computed on a regular grid. It uses
         scipy.interpolate.RegularGridInterpolator for efficient interpolation.
@@ -4092,14 +4104,14 @@ def from_grid(cls, grid_data, axes, inputs=None, outputs=None,
         >>> cd_data = 0.3 + 0.1 * M + 1e-7 * Re + 0.01 * A
         >>> # Create Function object
         >>> cd_func = Function.from_grid(
-        ...     cd_data, 
+        ...     cd_data,
         ...     [mach, reynolds, alpha],
         ...     inputs=['Mach', 'Reynolds', 'Alpha'],
         ...     outputs='Cd'
         ... )
         >>> # Evaluate at a point
         >>> cd_func(1.2, 3e5, 3.0)
-        
+
         Notes
         -----
         - Grid data must be on a regular (structured) grid.
@@ -4112,98 +4124,100 @@ def from_grid(cls, grid_data, axes, inputs=None, outputs=None,
         # Validate inputs
         if not isinstance(grid_data, np.ndarray):
             grid_data = np.array(grid_data)
-        
+
         if not isinstance(axes, (list, tuple)):
             raise ValueError("axes must be a list or tuple of 1D arrays")
-        
+
         # Ensure all axes are numpy arrays
-        axes = [np.array(axis) if not isinstance(axis, np.ndarray) else axis 
-                for axis in axes]
-        
+        axes = [
+            np.array(axis) if not isinstance(axis, np.ndarray) else axis
+            for axis in axes
+        ]
+
         # Check dimensions match
         if len(axes) != grid_data.ndim:
             raise ValueError(
                 f"Number of axes ({len(axes)}) must match grid_data dimensions "
                 f"({grid_data.ndim})"
             )
-        
+
         # Check each axis matches corresponding grid dimension
         for i, axis in enumerate(axes):
             if len(axis) != grid_data.shape[i]:
                 raise ValueError(
                     f"Axis {i} has {len(axis)} points but grid dimension {i} "
                     f"has {grid_data.shape[i]} points"
                 )
-        
+
         # Set default inputs if not provided
         if inputs is None:
             inputs = [f"x{i}" for i in range(len(axes))]
         elif len(inputs) != len(axes):
             raise ValueError(
                 f"Number of inputs ({len(inputs)}) must match number of axes ({len(axes)})"
             )
-        
+
         # Create a new Function instance
         func = cls.__new__(cls)
-        
+
         # Store grid-specific data first
         func._grid_axes = axes
         func._grid_data = grid_data
-        
+
         # Create RegularGridInterpolator
         # We handle extrapolation manually in __get_value_opt_grid,
         # so we set bounds_error=False and let it extrapolate linearly
         # (which we'll override when needed)
         func._grid_interpolator = RegularGridInterpolator(
-            axes, 
-            grid_data, 
-            method='linear',
+            axes,
+            grid_data,
+            method="linear",
             bounds_error=False,
-            fill_value=None  # Linear extrapolation (will be overridden by manual handling)
+            fill_value=None,  # Linear extrapolation (will be overridden by manual handling)
         )
-        
+
         # Create placeholder domain and image for compatibility
         # This flattens the grid for any code expecting these attributes
-        mesh = np.meshgrid(*axes, indexing='ij')
+        mesh = np.meshgrid(*axes, indexing="ij")
         domain_points = np.column_stack([m.ravel() for m in mesh])
         func._domain = domain_points
         func._image = grid_data.ravel()
-        
+
         # Set source as flattened data array (for compatibility with serialization, etc.)
         func.source = np.column_stack([domain_points, func._image])
-        
+
         # Initialize basic attributes
         func.__inputs__ = inputs
         func.__outputs__ = outputs if outputs is not None else "f"
         func.__interpolation__ = interpolation
         func.__extrapolation__ = extrapolation
-        func.title = kwargs.get('title', None)
+        func.title = kwargs.get("title", None)
         func.__img_dim__ = 1
         func.__cropped_domain__ = (None, None)
         func._source_type = SourceType.ARRAY
         func.__dom_dim__ = len(axes)
-        
+
         # Set basic array attributes for compatibility
         func.x_array = axes[0]
         func.x_initial, func.x_final = axes[0][0], axes[0][-1]
-        func.y_array = func._image[:len(axes[0])]  # Placeholder
+        func.y_array = func._image[: len(axes[0])]  # Placeholder
         func.y_initial, func.y_final = func._image[0], func._image[-1]
         if len(axes) > 2:
-            func.z_array = axes[2] 
+            func.z_array = axes[2]
             func.z_initial, func.z_final = axes[2][0], axes[2][-1]
-        
+
         # Set get_value_opt to use grid interpolation
         func.get_value_opt = func.__get_value_opt_grid
-        
+
         # Set interpolation and extrapolation functions
         func.__set_interpolation_func()
         func.__set_extrapolation_func()
-        
+
         # Set inputs and outputs properly
         func.set_inputs(inputs)
         func.set_outputs(outputs)
         func.set_title(func.title)
-        
+
         return func
 
     @classmethod

rocketpy/rocket/rocket.py

@@ -352,7 +352,7 @@ def __init__(  # pylint: disable=too-many-statements
                 "linear",
                 "constant",
             )
-        
+
         if isinstance(power_on_drag, Function):
             self.power_on_drag = power_on_drag
         else:

rocketpy/simulation/flight.py

@@ -1374,7 +1374,7 @@ def __get_drag_coefficient(
         # Check if drag function is multi-dimensional by examining its inputs
         if hasattr(drag_function, "__inputs__") and len(drag_function.__inputs__) > 1:
             # Multi-dimensional drag function - calculate additional parameters
-            
+
             # Calculate Reynolds number
             # Re = rho * V * L / mu
             # where L is characteristic length (rocket diameter)
@@ -1383,15 +1383,15 @@ def __get_drag_coefficient(
             freestream_speed = np.linalg.norm(freestream_velocity_body)
             characteristic_length = 2 * self.rocket.radius  # Diameter
             reynolds = rho * freestream_speed * characteristic_length / mu
-            
+
             # Calculate angle of attack
             # Angle between freestream velocity and rocket axis (z-axis in body frame)
             # The z component of freestream velocity in body frame
             if hasattr(freestream_velocity_body, "z"):
                 stream_vz_b = -freestream_velocity_body.z
             else:
                 stream_vz_b = -freestream_velocity_body[2]
-            
+
             # Normalize and calculate angle
             if freestream_speed > 1e-6:
                 cos_alpha = stream_vz_b / freestream_speed
@@ -1401,11 +1401,11 @@ def __get_drag_coefficient(
                 alpha_deg = np.rad2deg(alpha_rad)
             else:
                 alpha_deg = 0.0
-            
+
             # Determine which parameters to pass based on input names
             input_names = [name.lower() for name in drag_function.__inputs__]
             args = []
-            
+
             for name in input_names:
                 if "mach" in name or name == "m":
                     args.append(mach)
@@ -1416,7 +1416,7 @@ def __get_drag_coefficient(
                 else:
                     # Unknown parameter, default to mach
                     args.append(mach)
-            
+
             return drag_function.get_value_opt(*args)
         else:
             # 1D drag function - only mach number
@@ -1458,7 +1458,7 @@ def udot_rail1(self, t, u, post_processing=False):
             + (vz) ** 2
         ) ** 0.5
         free_stream_mach = free_stream_speed / self.env.speed_of_sound.get_value_opt(z)
-        
+
         # For rail motion, rocket is constrained - velocity mostly along z-axis in body frame
         # Calculate velocity in body frame (simplified for rail)
         a11 = 1 - 2 * (e2**2 + e3**2)
@@ -1470,18 +1470,18 @@ def udot_rail1(self, t, u, post_processing=False):
         a31 = 2 * (e1 * e3 - e0 * e2)
         a32 = 2 * (e2 * e3 + e0 * e1)
         a33 = 1 - 2 * (e1**2 + e2**2)
-        
+
         vx_b = a11 * vx + a21 * vy + a31 * vz
         vy_b = a12 * vx + a22 * vy + a32 * vz
         vz_b = a13 * vx + a23 * vy + a33 * vz
-        
+
         # Freestream velocity in body frame
         wind_vx = self.env.wind_velocity_x.get_value_opt(z)
         wind_vy = self.env.wind_velocity_y.get_value_opt(z)
         stream_vx_b = a11 * (wind_vx - vx) + a21 * (wind_vy - vy) + a31 * (-vz)
         stream_vy_b = a12 * (wind_vx - vx) + a22 * (wind_vy - vy) + a32 * (-vz)
         stream_vz_b = a13 * (wind_vx - vx) + a23 * (wind_vy - vy) + a33 * (-vz)
-        
+
         drag_coeff = self.__get_drag_coefficient(
             self.rocket.power_on_drag,
             free_stream_mach,
@@ -1660,12 +1660,18 @@ def u_dot(self, t, u, post_processing=False):  # pylint: disable=too-many-locals
         vx_b = a11 * vx + a21 * vy + a31 * vz
         vy_b = a12 * vx + a22 * vy + a32 * vz
         vz_b = a13 * vx + a23 * vy + a33 * vz
-        
+
         # Calculate freestream velocity in body frame
-        stream_vx_b = a11 * (wind_velocity_x - vx) + a21 * (wind_velocity_y - vy) + a31 * (-vz)
-        stream_vy_b = a12 * (wind_velocity_x - vx) + a22 * (wind_velocity_y - vy) + a32 * (-vz)
-        stream_vz_b = a13 * (wind_velocity_x - vx) + a23 * (wind_velocity_y - vy) + a33 * (-vz)
-        
+        stream_vx_b = (
+            a11 * (wind_velocity_x - vx) + a21 * (wind_velocity_y - vy) + a31 * (-vz)
+        )
+        stream_vy_b = (
+            a12 * (wind_velocity_x - vx) + a22 * (wind_velocity_y - vy) + a32 * (-vz)
+        )
+        stream_vz_b = (
+            a13 * (wind_velocity_x - vx) + a23 * (wind_velocity_y - vy) + a33 * (-vz)
+        )
+
         # Determine aerodynamics forces
         # Determine Drag Force
         if t < self.rocket.motor.burn_out_time:
@@ -1958,7 +1964,7 @@ def u_dot_generalized(self, t, u, post_processing=False):  # pylint: disable=too
         # Calculate freestream velocity in body frame
         freestream_velocity = wind_velocity - v
         freestream_velocity_body = Kt @ freestream_velocity
-        
+
         if self.rocket.motor.burn_start_time < t < self.rocket.motor.burn_out_time:
             pressure = self.env.pressure.get_value_opt(z)
             net_thrust = max(