running black

Author: FranzYuri

rocketpy/AeroSurfaces.py

@@ -194,7 +194,7 @@ def __str__(self):
         rep = f"NoseCone Object. Name: {self.name}, kind: {self.kind}"
 
         return rep
-    
+
     def evaluateGeometricalParameters(self):
         """Calculates and returns nose cone's radius ratio.
 
@@ -229,7 +229,7 @@ def evaluateLiftCoefficient(self):
             The output is the lift coefficient of the nose cone.
         """
         # Calculate clalpha
-        self.clalpha = 2 * self.radiusRatio**2
+        self.clalpha = 2 * self.radiusRatio ** 2
         self.cl = Function(
             lambda alpha, mach: self.clalpha * alpha,
             ["Alpha (rad)", "Mach"],
@@ -441,7 +441,7 @@ def __init__(
 
         # Compute auxiliary geometrical parameters
         d = 2 * rocketRadius
-        Aref = np.pi * rocketRadius**2  # Reference area
+        Aref = np.pi * rocketRadius ** 2  # Reference area
 
         # Store values
         self._n = n
@@ -532,7 +532,7 @@ def airfoil(self, value):
     @abstractmethod
     def __str__(self):
         pass
-    
+
     @abstractmethod
     def evaluateCenterOfPressure(self):
         """Calculates and returns the fin set's center of pressure position in local
@@ -677,7 +677,7 @@ def evaluateRollParameters(self):
             * self.clalphaSingleFin
             * np.cos(self.cantAngleRad)
             * self.rollGeometricalConstant
-            / (self.Aref * self.d**2)
+            / (self.Aref * self.d ** 2)
         )  # Function of mach number
         cldOmega.setInputs("Mach")
         cldOmega.setOutputs("Roll moment damping coefficient derivative")
@@ -702,11 +702,11 @@ def __beta(_, mach):
         """
 
         if mach < 0.8:
-            return np.sqrt(1 - mach**2)
+            return np.sqrt(1 - mach ** 2)
         elif mach < 1.1:
-            return np.sqrt(1 - 0.8**2)
+            return np.sqrt(1 - 0.8 ** 2)
         else:
-            return np.sqrt(mach**2 - 1)
+            return np.sqrt(mach ** 2 - 1)
 
     # Defines number of fins  factor
     def __finNumCorrection(_, n):
@@ -1172,11 +1172,11 @@ def draw(self):
             / (3 * (self.rootChord + self.tipChord))
         )
         Yma_end = (
-            2 * self.rootChord**2
+            2 * self.rootChord ** 2
             + self.rootChord * self.sweepLength
             + 2 * self.rootChord * self.tipChord
             + 2 * self.sweepLength * self.tipChord
-            + 2 * self.tipChord**2
+            + 2 * self.tipChord ** 2
         ) / (3 * (self.rootChord + self.tipChord))
         Yma_line = plt.Line2D(
             (Yma_start, Yma_end),
@@ -1238,7 +1238,7 @@ def evaluateGeometricalParameters(self):
 
         Yr = self.rootChord + self.tipChord
         Af = Yr * self.span / 2  # Fin area
-        AR = 2 * self.span**2 / Af  # Fin aspect ratio
+        AR = 2 * self.span ** 2 / Af  # Fin aspect ratio
         gamma_c = np.arctan(
             (self.sweepLength + 0.5 * self.tipChord - 0.5 * self.rootChord)
             / (self.span)
@@ -1255,30 +1255,30 @@ def evaluateGeometricalParameters(self):
         # Parameters for Roll Moment.
         # Documented at: https://github.com/RocketPy-Team/RocketPy/blob/master/docs/technical/aerodynamics/Roll_Equations.pdf
         rollGeometricalConstant = (
-            (self.rootChord + 3 * self.tipChord) * self.span**3
+            (self.rootChord + 3 * self.tipChord) * self.span ** 3
             + 4
             * (self.rootChord + 2 * self.tipChord)
             * self.rocketRadius
-            * self.span**2
-            + 6 * (self.rootChord + self.tipChord) * self.span * self.rocketRadius**2
+            * self.span ** 2
+            + 6 * (self.rootChord + self.tipChord) * self.span * self.rocketRadius ** 2
         ) / 12
         rollDampingInterferenceFactor = 1 + (
             ((tau - λ) / (tau)) - ((1 - λ) / (tau - 1)) * np.log(tau)
         ) / (
-            ((tau + 1) * (tau - λ)) / (2) - ((1 - λ) * (tau**3 - 1)) / (3 * (tau - 1))
+            ((tau + 1) * (tau - λ)) / (2) - ((1 - λ) * (tau ** 3 - 1)) / (3 * (tau - 1))
         )
-        rollForcingInterferenceFactor = (1 / np.pi**2) * (
-            (np.pi**2 / 4) * ((tau + 1) ** 2 / tau**2)
-            + ((np.pi * (tau**2 + 1) ** 2) / (tau**2 * (tau - 1) ** 2))
-            * np.arcsin((tau**2 - 1) / (tau**2 + 1))
+        rollForcingInterferenceFactor = (1 / np.pi ** 2) * (
+            (np.pi ** 2 / 4) * ((tau + 1) ** 2 / tau ** 2)
+            + ((np.pi * (tau ** 2 + 1) ** 2) / (tau ** 2 * (tau - 1) ** 2))
+            * np.arcsin((tau ** 2 - 1) / (tau ** 2 + 1))
             - (2 * np.pi * (tau + 1)) / (tau * (tau - 1))
-            + ((tau**2 + 1) ** 2)
-            / (tau**2 * (tau - 1) ** 2)
-            * (np.arcsin((tau**2 - 1) / (tau**2 + 1))) ** 2
+            + ((tau ** 2 + 1) ** 2)
+            / (tau ** 2 * (tau - 1) ** 2)
+            * (np.arcsin((tau ** 2 - 1) / (tau ** 2 + 1))) ** 2
             - (4 * (tau + 1))
             / (tau * (tau - 1))
-            * np.arcsin((tau**2 - 1) / (tau**2 + 1))
-            + (8 / (tau - 1) ** 2) * np.log((tau**2 + 1) / (2 * tau))
+            * np.arcsin((tau ** 2 - 1) / (tau ** 2 + 1))
+            + (8 / (tau - 1) ** 2) * np.log((tau ** 2 + 1) / (2 * tau))
         )
 
         # Store values
@@ -1444,13 +1444,12 @@ def __init__(
         self.evaluateRollParameters()
 
         return None
-    
+
     def __str__(self):
         rep = f"EllipticalFins Object. Name: {self.name}"
 
         return rep
 
-
     def evaluateCenterOfPressure(self):
         """Calculates and returns the center of pressure of the fin set in local
         coordinates. The center of pressure position is saved and stored as a tuple.
@@ -1560,17 +1559,17 @@ def evaluateGeometricalParameters(self):
         # Compute auxiliary geometrical parameters
         Af = (np.pi * self.rootChord / 2 * self.span) / 2  # Fin area
         gamma_c = 0  # Zero for elliptical fins
-        AR = 2 * self.span**2 / Af  # Fin aspect ratio
+        AR = 2 * self.span ** 2 / Af  # Fin aspect ratio
         Yma = (
-            self.span / (3 * np.pi) * np.sqrt(9 * np.pi**2 - 64)
+            self.span / (3 * np.pi) * np.sqrt(9 * np.pi ** 2 - 64)
         )  # Span wise coord of mean aero chord
         rollGeometricalConstant = (
             self.rootChord
             * self.span
             * (
-                3 * np.pi * self.span**2
+                3 * np.pi * self.span ** 2
                 + 32 * self.rocketRadius * self.span
-                + 12 * np.pi * self.rocketRadius**2
+                + 12 * np.pi * self.rocketRadius ** 2
             )
             / 48
         )
@@ -1579,45 +1578,45 @@ def evaluateGeometricalParameters(self):
         tau = (self.span + self.rocketRadius) / self.rocketRadius
         liftInterferenceFactor = 1 + 1 / tau
         rollDampingInterferenceFactor = 1 + (
-            (self.rocketRadius**2)
+            (self.rocketRadius ** 2)
             * (
                 2
-                * (self.rocketRadius**2)
-                * np.sqrt(self.span**2 - self.rocketRadius**2)
+                * (self.rocketRadius ** 2)
+                * np.sqrt(self.span ** 2 - self.rocketRadius ** 2)
                 * np.log(
                     (
-                        2 * self.span * np.sqrt(self.span**2 - self.rocketRadius**2)
-                        + 2 * self.span**2
+                        2 * self.span * np.sqrt(self.span ** 2 - self.rocketRadius ** 2)
+                        + 2 * self.span ** 2
                     )
                     / self.rocketRadius
                 )
                 - 2
-                * (self.rocketRadius**2)
-                * np.sqrt(self.span**2 - self.rocketRadius**2)
+                * (self.rocketRadius ** 2)
+                * np.sqrt(self.span ** 2 - self.rocketRadius ** 2)
                 * np.log(2 * self.span)
-                + 2 * self.span**3
-                - np.pi * self.rocketRadius * self.span**2
-                - 2 * (self.rocketRadius**2) * self.span
-                + np.pi * self.rocketRadius**3
+                + 2 * self.span ** 3
+                - np.pi * self.rocketRadius * self.span ** 2
+                - 2 * (self.rocketRadius ** 2) * self.span
+                + np.pi * self.rocketRadius ** 3
             )
         ) / (
             2
-            * (self.span**2)
+            * (self.span ** 2)
             * (self.span / 3 + np.pi * self.rocketRadius / 4)
-            * (self.span**2 - self.rocketRadius**2)
+            * (self.span ** 2 - self.rocketRadius ** 2)
         )
-        rollForcingInterferenceFactor = (1 / np.pi**2) * (
-            (np.pi**2 / 4) * ((tau + 1) ** 2 / tau**2)
-            + ((np.pi * (tau**2 + 1) ** 2) / (tau**2 * (tau - 1) ** 2))
-            * np.arcsin((tau**2 - 1) / (tau**2 + 1))
+        rollForcingInterferenceFactor = (1 / np.pi ** 2) * (
+            (np.pi ** 2 / 4) * ((tau + 1) ** 2 / tau ** 2)
+            + ((np.pi * (tau ** 2 + 1) ** 2) / (tau ** 2 * (tau - 1) ** 2))
+            * np.arcsin((tau ** 2 - 1) / (tau ** 2 + 1))
             - (2 * np.pi * (tau + 1)) / (tau * (tau - 1))
-            + ((tau**2 + 1) ** 2)
-            / (tau**2 * (tau - 1) ** 2)
-            * (np.arcsin((tau**2 - 1) / (tau**2 + 1))) ** 2
+            + ((tau ** 2 + 1) ** 2)
+            / (tau ** 2 * (tau - 1) ** 2)
+            * (np.arcsin((tau ** 2 - 1) / (tau ** 2 + 1))) ** 2
             - (4 * (tau + 1))
             / (tau * (tau - 1))
-            * np.arcsin((tau**2 - 1) / (tau**2 + 1))
-            + (8 / (tau - 1) ** 2) * np.log((tau**2 + 1) / (2 * tau))
+            * np.arcsin((tau ** 2 - 1) / (tau ** 2 + 1))
+            + (8 / (tau - 1) ** 2) * np.log((tau ** 2 + 1) / (2 * tau))
         )
 
         # Store values
@@ -1828,7 +1827,7 @@ def evaluateCenterOfPressure(self):
         """
         # Calculate cp position in local coordinates
         r = self.topRadius / self.bottomRadius
-        cpz = (self.length / 3) * (1 + (1 - r) / (1 - r**2))
+        cpz = (self.length / 3) * (1 + (1 - r) / (1 - r ** 2))
 
         # Store values as class attributes
         self.cpx = 0