verified ruff check changes

Author: peterdsharpe

aerosandbox/aerodynamics/aero_2D/airfoil_optimizer/airfoil_optimizer.py

@@ -3,6 +3,7 @@
 from aerosandbox.geometry.airfoil.airfoil_families import get_kulfan_coordinates
 from scipy import optimize
 import matplotlib.pyplot as plt
+from dataclasses import dataclass, field
 
 if __name__ == "__main__":
     ### Design Conditions
@@ -101,9 +102,14 @@ def draw(
         plt.pause(0.001)
 
     ### Utilities for tracking the design vector and objective throughout the optimization run
-    iteration = 0
-    xs = []
-    fs = []
+    @dataclass
+    class OptimizationState:
+        """Holds state for the optimization to avoid globals."""
+        iteration: int = 0
+        xs: list = field(default_factory=list)
+        fs: list = field(default_factory=list)
+
+    state = OptimizationState()
 
     def augmented_objective(x):
         """
@@ -140,19 +146,18 @@ def augmented_objective(x):
             np.minimum(0, (airfoil.local_thickness(0.30) - 0.12) / 0.005) ** 2
         )  # Spar thickness constraint
 
-        xs.append(x)
-        fs.append(objective)
+        state.xs.append(x)
+        state.fs.append(objective)
 
         return objective * (1 + penalty)
 
     def callback(x):
-        global iteration
-        iteration += 1
-        print(f"Iteration {iteration}: Cd = {fs[-1]:.6f}")
-        if iteration % 1 == 0:
+        state.iteration += 1
+        print(f"Iteration {state.iteration}: Cd = {state.fs[-1]:.6f}")
+        if state.iteration % 1 == 0:
             airfoil = make_airfoil(x)
             draw(airfoil)
-            ax.set_title(f"Airfoil Optimization: Iteration {iteration}")
+            ax.set_title(f"Airfoil Optimization: Iteration {state.iteration}")
             airfoil.write_dat("optimized_airfoil.dat")
 
     draw(initial_airfoil)

aerosandbox/aerodynamics/aero_3D/lifting_line.py

@@ -1275,9 +1275,6 @@ def draw(
 if __name__ == "__main__":
     import aerosandbox as asb
     import aerosandbox.numpy as np
-    from aerosandbox.aerodynamics.aero_3D.test_aero_3D.geometries.conventional import (
-        airplane,
-    )
     import matplotlib.pyplot as plt
     import aerosandbox.tools.pretty_plots as p
 

aerosandbox/aerodynamics/aero_3D/test_aero_3D/test_aero_buildup/test_moment_validation/test_fuselage_moment_and_derivatives.py

@@ -266,15 +266,15 @@ def A(x):  # cross-sectional area as a function of distance along fuselage, x
     # TODO add assertions
 
     ##### Slender body theory
-    l = 1  # length of fuselage
+    length = 1  # length of fuselage
     alpha_rad = np.radians(analysis.op_point.alpha)
 
     from scipy import integrate
 
     def alpha_tilde(x):
         return alpha_rad - dzdx(x)
 
-    CL = 2 / airplane.s_ref * A(l) * alpha_tilde(l)
+    CL = 2 / airplane.s_ref * A(length) * alpha_tilde(length)
     print(f"CL_slb: {CL}")
     assert aero["CL"] == pytest.approx(CL, abs=0.01)
 
@@ -283,9 +283,9 @@ def alpha_tilde(x):
         / airplane.s_ref
         / airplane.c_ref
         * (
-            (fuselage.volume() - l * A(l)) * alpha_rad
-            + l * A(l) * dzdx(l)
-            - integrate.quad(lambda xi: A(xi) * dzdx(xi), 0, l)[0]
+            (fuselage.volume() - length * A(length)) * alpha_rad
+            + length * A(length) * dzdx(length)
+            - integrate.quad(lambda xi: A(xi) * dzdx(xi), 0, length)[0]
         )
     )
 

aerosandbox/atmosphere/atmosphere.py

@@ -77,21 +77,21 @@ def __getitem__(self, index) -> "Atmosphere":
         Returns: A new Atmosphere instance, where each attribute is subscripted at the given value, if possible.
 
         """
-        l = len(self)
+        self_length = len(self)
 
         def get_item_of_attribute(a):
             if hasattr(a, "__len__") and hasattr(a, "__getitem__"):
                 if len(a) == 1:
                     return a[0]
-                elif len(a) == l:
+                elif len(a) == self_length:
                     return a[index]
                 else:
                     try:
                         return a[index]
                     except IndexError:
                         raise IndexError(
                             f"A state variable could not be indexed; it has length {len(a)} while the"
-                            f"parent has length {l}."
+                            f"parent has length {self_length}."
                         )
             else:
                 return a

aerosandbox/dynamics/point_mass/common_point_mass.py

@@ -199,21 +199,21 @@ def __getitem__(self, index: int | slice):
         Returns: A new Dynamics instance, where each attribute is subscripted at the given value, if possible.
 
         """
-        l = len(self)
+        self_length = len(self)
 
         def get_item_of_attribute(a):
             if hasattr(a, "__len__") and hasattr(a, "__getitem__"):
                 if len(a) == 1:
                     return a[0]
-                elif len(a) == l:
+                elif len(a) == self_length:
                     return a[index]
                 else:
                     try:
                         return a[index]
                     except IndexError:
                         raise IndexError(
                             f"A state variable could not be indexed; it has length {len(a)} while the"
-                            f"parent has length {l}."
+                            f"parent has length {self_length}."
                         )
             else:
                 return a

aerosandbox/geometry/airfoil/airfoil.py

@@ -1337,40 +1337,40 @@ def set_TE_thickness(
             y_adjustment = s_adjustment
 
         ### Decompose the existing airfoil coordinates to upper and lower sides, and x and y.
-        u = self.upper_coordinates()
-        ux = u[:, 0]
-        uy = u[:, 1]
+        upper = self.upper_coordinates()
+        upper_x = upper[:, 0]
+        upper_y = upper[:, 1]
 
-        le_x = ux[-1]
+        le_x = upper_x[-1]
 
-        l = self.lower_coordinates()[1:]
-        lx = l[:, 0]
-        ly = l[:, 1]
+        lower = self.lower_coordinates()[1:]
+        lower_x = lower[:, 0]
+        lower_y = lower[:, 1]
 
-        te_x = (ux[0] + lx[-1]) / 2
+        te_x = (upper_x[0] + lower_x[-1]) / 2
 
         ### Create modified versions of the upper and lower coordinates
-        new_u = np.stack(
+        new_upper = np.stack(
             arrays=[
-                ux + x_adjustment * (ux - le_x) / (te_x - le_x),
-                uy + y_adjustment * (ux - le_x) / (te_x - le_x),
+                upper_x + x_adjustment * (upper_x - le_x) / (te_x - le_x),
+                upper_y + y_adjustment * (upper_x - le_x) / (te_x - le_x),
             ],
             axis=1,
         )
-        new_l = np.stack(
+        new_lower = np.stack(
             arrays=[
-                lx - x_adjustment * (lx - le_x) / (te_x - le_x),
-                ly - y_adjustment * (lx - le_x) / (te_x - le_x),
+                lower_x - x_adjustment * (lower_x - le_x) / (te_x - le_x),
+                lower_y - y_adjustment * (lower_x - le_x) / (te_x - le_x),
             ],
             axis=1,
         )
 
         ### If the desired thickness is zero, ensure that is precisely reached.
         if thickness == 0:
-            new_l[-1] = new_u[0]
+            new_lower[-1] = new_upper[0]
 
         ### Combine the upper and lower surface coordinates into a single array.
-        new_coordinates = np.concatenate([new_u, new_l], axis=0)
+        new_coordinates = np.concatenate([new_upper, new_lower], axis=0)
 
         ### Return a new Airfoil with the desired coordinates.
         return Airfoil(name=self.name, coordinates=new_coordinates)

aerosandbox/library/aerodynamics/inviscid.py

@@ -51,9 +51,9 @@ def oswalds_efficiency(
     sweep = np.clip(sweep, 0, 90)  # TODO input proper analytic continuation
 
     def f(
-        l,
+        taper,
     ):  # f(lambda), given as Eq. 36 in the Nita and Scholz paper (see parent docstring).
-        return 0.0524 * l**4 - 0.15 * l**3 + 0.1659 * l**2 - 0.0706 * l + 0.0119
+        return 0.0524 * taper**4 - 0.15 * taper**3 + 0.1659 * taper**2 - 0.0706 * taper + 0.0119
 
     delta_lambda = -0.357 + 0.45 * np.exp(-0.0375 * sweep)
     # Eq. 37 in Nita & Scholz.

aerosandbox/library/aerodynamics/unsteady.py

@@ -185,8 +185,8 @@ def integrand(sigma, s, chord):
 
     lift_coefficient = np.zeros_like(reduced_time)
     for i, s in enumerate(reduced_time):
-        I = quad(integrand, 0, s, args=(s, chord))[0]
-        lift_coefficient[i] = 2 * np.pi * I / plate_velocity
+        integrated_value = quad(integrand, 0, s, args=(s, chord))[0]
+        lift_coefficient[i] = 2 * np.pi * integrated_value / plate_velocity
 
     return lift_coefficient
 
@@ -235,9 +235,9 @@ def integrand(sigma, s):
     lift_coefficient = np.zeros_like(reduced_time)
 
     for i, s in enumerate(reduced_time):
-        I = quad(integrand, 0, s, args=s)[0]
-        # print(I)
-        lift_coefficient[i] = 2 * np.pi * (AoA_function(s) * wagners_function(0) + I)
+        integrated_value = quad(integrand, 0, s, args=s)[0]
+        # print(integrated_value)
+        lift_coefficient[i] = 2 * np.pi * (AoA_function(s) * wagners_function(0) + integrated_value)
 
     return lift_coefficient
 
@@ -414,7 +414,7 @@ def linear_ramp_pitch(reduced_time: float) -> float:
     )
     ax2.set_ylabel("Angle of Attack, degrees")
     lns = ln1 + ln2 + ln3
-    labs = [l.get_label() for l in lns]
+    labs = [line.get_label() for line in lns]
     ax2.legend(lns, labs, loc="lower right")
     plt.title("Gust and pitch example profiles")
 

aerosandbox/library/aerodynamics/viscous.py

@@ -1,5 +1,6 @@
 import aerosandbox.numpy as np
 from typing import Literal
+import warnings
 
 
 def Cd_cylinder(
@@ -196,9 +197,6 @@ def Cd_flat_plate_normal():
     return 2.202
 
 
-import warnings
-
-
 def Cl_2412(alpha, Re_c):
     # A curve fit I did to a NACA 2412 airfoil, 2D XFoil data
     # Within -2 < alpha < 12 and 10^5 < Re_c < 10^7, has R^2 = 0.9892
@@ -337,25 +335,19 @@ def Cd_wave_e216(Cl, mach, sweep=0.0):
     mach = np.fmax(mach, 0)
     mach_perpendicular = mach * np.cosd(sweep)  # Relation from FVA Eq. 8.176
     Cl_perpendicular = Cl / np.cosd(sweep) ** 2  # Relation from FVA Eq. 8.177
-
-    # Coeffs
-    c0 = 7.2685945744797997e-01
-    c1 = -1.5483144040727698e-01
-    c3 = 2.1305118052118968e-01
-    c4 = 7.8812272501525316e-01
-    c5 = 3.3888938102072169e-03
-    l0 = 1.5298928303149546e00
-    l1 = 5.2389999717540392e-01
-
-    m = mach_perpendicular
-    l = Cl_perpendicular
-
-    Cd_wave = (
-        np.fmax(m - (c0 + c1 * np.sqrt(c3 + (l - c4) ** 2) + c5 * l), 0) * (l0 + l1 * l)
+    return (
+        np.fmax(
+            mach_perpendicular
+            - (
+                7.2685945744797997e-01
+                + -1.5483144040727698e-01 * np.sqrt(2.1305118052118968e-01 + (Cl_perpendicular - 7.8812272501525316e-01) ** 2)
+                + 3.3888938102072169e-03 * Cl_perpendicular
+            ),
+            0
+        )
+        * (1.5298928303149546e00 + 5.2389999717540392e-01 * Cl_perpendicular)
     ) ** 2
 
-    return Cd_wave
-
 
 def Cl_rae2822(alpha, Re_c):
     # A curve fit I did to a RAE2822 airfoil, 2D XFoil data. Incompressible flow.
@@ -451,20 +443,14 @@ def Cd_wave_rae2822(Cl, mach, sweep=0.0):
     mach = np.fmax(mach, 0)
     mach_perpendicular = mach * np.cosd(sweep)  # Relation from FVA Eq. 8.176
     Cl_perpendicular = Cl / np.cosd(sweep) ** 2  # Relation from FVA Eq. 8.177
-
-    # Coeffs
-    c2 = 4.5776476424519119e00
-    mc0 = 9.5623337929607111e-01
-    mc1 = 2.0552787101770234e-01
-    mc2 = 1.1259268018737063e00
-    mc3 = 1.9538856688443659e-01
-
-    m = mach_perpendicular
-    l = Cl_perpendicular
-
-    Cd_wave = np.fmax(m - (mc0 - mc1 * np.sqrt(mc2 + (l - mc3) ** 2)), 0) ** 2 * c2
-
-    return Cd_wave
+    return np.fmax(
+        mach_perpendicular
+        - (
+            9.5623337929607111e-01
+            - 2.0552787101770234e-01 * np.sqrt(1.1259268018737063e00 + (Cl_perpendicular - 1.9538856688443659e-01) ** 2)
+        ),
+        0
+    ) ** 2 * 4.5776476424519119e00
 
 
 def fuselage_upsweep_drag_area(

aerosandbox/library/mass_structural.py

@@ -183,10 +183,10 @@ def mass_hpa_tail_boom(
     :param mean_tail_surface_area: mean of the areas of the tail surfaces (elevator, rudder)
     :return: mass of the tail boom [m]
     """
-    l = length_tail_boom
+    length = length_tail_boom
     q = dynamic_pressure_at_manuever_speed
     area = mean_tail_surface_area
-    w_tb = (l * 1.14e-1 + l**2 * 1.96e-2) * (1 + ((q * area) / 78.5 - 1) / 2)
+    w_tb = (length * 1.14e-1 + length**2 * 1.96e-2) * (1 + ((q * area) / 78.5 - 1) / 2)
 
     return w_tb