MNT: renamed linear_grid to regular_grid for easy to understand nomenclature

- MNT: added a fallback to reynolds calculation in flight.py to avoid mu is zero case

- MNT: updated test_shepard_fallback_warning name and docstring to match implementation in test_function_grid.py

Author: aZira371

rocketpy/mathutils/function.py

@@ -44,7 +44,7 @@
     "spline": 3,
     "shepard": 4,
     "rbf": 5,
-    "linear_grid": 6,
+    "regular_grid": 6,
 }
 EXTRAPOLATION_TYPES = {"zero": 0, "natural": 1, "constant": 2}
 
@@ -463,7 +463,7 @@ def rbf_interpolation(x, x_min, x_max, x_data, y_data, coeffs):  # pylint: disab
 
             self._interpolation_func = rbf_interpolation
 
-        elif interpolation == 6:  # linear_grid (RegularGridInterpolator)
+        elif interpolation == 6:  # regular_grid (RegularGridInterpolator)
             # 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
@@ -4000,11 +4000,16 @@ def __validate_interpolation(self, interpolation):
         elif self.__dom_dim__ > 1:
             if interpolation is None:
                 interpolation = "shepard"
-            if interpolation.lower() not in ["shepard", "linear", "rbf", "linear_grid"]:
+            if interpolation.lower() not in [
+                "shepard",
+                "linear",
+                "rbf",
+                "regular_grid",
+            ]:
                 warnings.warn(
                     (
                         "Interpolation method set to 'shepard'. The methods "
-                        "'linear', 'shepard', 'rbf' and 'linear_grid' are supported for "
+                        "'linear', 'shepard', 'rbf' and 'regular_grid' are supported for "
                         "multiple dimensions."
                     ),
                 )
@@ -4066,7 +4071,7 @@ def from_grid(
         axes,
         inputs=None,
         outputs=None,
-        interpolation="linear_grid",
+        interpolation="regular_grid",
         extrapolation="constant",
         **kwargs,
     ):  # pylint: disable=too-many-statements #TODO: Refactor this method into smaller methods
@@ -4092,8 +4097,8 @@ def from_grid(
         outputs : str, optional
             Name of the output variable. For example: 'Cd'.
         interpolation : str, optional
-            Interpolation method. Default is 'linear_grid'.
-            Currently only 'linear_grid' is supported for grid data.
+            Interpolation method. Default is 'regular_grid'.
+            Currently only 'regular_grid' is supported for grid data.
         extrapolation : str, optional
             Extrapolation behavior. Default is ``'constant'`` which clamps to
             edge values. Supported options are::
@@ -4236,8 +4241,21 @@ def from_grid(
         # 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_initial, func.y_final = func._image[0], func._image[-1]
+        # For grid-based (N-D) functions, a 1-D `y_array` is not a meaningful
+        # representation of the function values. Some legacy code paths and
+        # serialization expect a `y_array` attribute to exist, so provide the
+        # full flattened image for compatibility rather than a truncated slice.
+        # Callers should avoid relying on `y_array` for multidimensional
+        # Functions; use the interpolator / `get_value_opt` instead.
+        func.y_array = func._image
+        # Use the global min/max of the flattened image as a sensible
+        # `y_initial`/`y_final` for compatibility with code that inspects
+        # scalar bounds. These describe the image range, not an ordering
+        # along any particular axis.
+        func.y_initial, func.y_final = (
+            float(func._image.min()),
+            float(func._image.max()),
+        )
         if len(axes) > 2:
             func.z_array = axes[2]
             func.z_initial, func.z_final = axes[2][0], axes[2][-1]

rocketpy/simulation/flight.py

@@ -1411,7 +1411,18 @@ def __get_drag_coefficient(self, drag_function, mach, z, freestream_velocity_bod
             mu = self.env.dynamic_viscosity.get_value_opt(z)
             freestream_speed = np.linalg.norm(freestream_velocity_body)
             characteristic_length = 2 * self.rocket.radius  # Diameter
-            reynolds = rho * freestream_speed * characteristic_length / mu
+            # Defensive: avoid division by zero or non-finite viscosity values.
+            # Use a small epsilon fallback if `mu` is zero, negative, NaN or infinite.
+            try:
+                mu_val = float(mu)
+            except Exception:
+                mu_val = 0.0
+            if not np.isfinite(mu_val) or mu_val <= 0.0:
+                mu_safe = 1e-10
+            else:
+                mu_safe = mu_val
+
+            reynolds = rho * freestream_speed * characteristic_length / mu_safe
 
             # Calculate angle of attack
             # Angle between freestream velocity and rocket axis (z-axis in body frame)

tests/unit/mathutils/test_function_grid.py

@@ -141,23 +141,26 @@ def test_from_grid_backward_compatibility():
     assert func3(2) == 4
 
 
-def test_shepard_fallback_warning():
-    """Test that shepard_fallback is triggered and emits a warning.
-
-    When linear_grid interpolation is set but no grid interpolator is available,
-    the Function class should fall back to shepard interpolation and emit a warning.
+def test_regular_grid_without_grid_interpolator_warns():
+    """Test that setting `regular_grid` without a grid interpolator warns.
+
+    This test constructs a Function from scattered points (no structured
+    grid). If `regular_grid` interpolation is later selected without a
+    grid interpolator being configured, the implementation currently
+    falls back to shepard interpolation and should emit a warning. The
+    test ensures a warning is raised in this scenario.
     """
     # Create a 2D function with scattered points (not structured grid)
     source = [(0, 0, 0), (1, 0, 1), (0, 1, 2), (1, 1, 3)]
     func = Function(
         source=source, inputs=["x", "y"], outputs="z", interpolation="shepard"
     )
 
-    # Now manually change interpolation to linear_grid without setting up the grid
+    # Now manually change interpolation to regular_grid without setting up the grid
     # This simulates the fallback scenario
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
-        func.set_interpolation("linear_grid")
+        func.set_interpolation("regular_grid")
 
         # Check that a warning was issued
         assert len(w) == 1
@@ -168,7 +171,7 @@ def test_shepard_fallback_2d_interpolation():
     """Test that shepard_fallback produces correct interpolation for 2D data.
 
     This test verifies the fallback interpolation works correctly when
-    linear_grid is set without a grid interpolator.
+    regular_grid is set without a grid interpolator.
     """
     # Create a 2D function: z = x + y
     source = [
@@ -191,7 +194,7 @@ def test_shepard_fallback_2d_interpolation():
     # Trigger fallback
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")  # Suppress warnings for this test
-        func_fallback.set_interpolation("linear_grid")
+        func_fallback.set_interpolation("regular_grid")
 
     # Test that both produce the same results at exact points
     assert func_fallback(0, 0) == func_shepard(0, 0)
@@ -237,7 +240,7 @@ def test_shepard_fallback_3d_interpolation():
     # Trigger fallback
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
-        func_fallback.set_interpolation("linear_grid")
+        func_fallback.set_interpolation("regular_grid")
 
     # Test that both produce the same results at exact points
     assert func_fallback(0, 0, 0) == func_shepard(0, 0, 0)
@@ -270,7 +273,7 @@ def test_shepard_fallback_at_exact_data_points():
     # Trigger fallback
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
-        func.set_interpolation("linear_grid")
+        func.set_interpolation("regular_grid")
 
     # Test exact data points - should return exact values
     assert func(0, 0) == 10