turbo-design 1.0.11__py3-none-any.whl → 1.1.1__py3-none-any.whl

{turbo_design-1.0.11.dist-info → turbo_design-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: turbo-design
-Version: 1.0.11
+Version: 1.1.1
 Summary: TurboDesign is a library used to design turbines and compressors using radial equilibrium.
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov

{turbo_design-1.0.11.dist-info → turbo_design-1.1.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 turbodesign/__init__.py,sha256=N8Nu0I1vrlEHYJZZ7yhhg-FtbNbLyrgjy7hoicygUqg,325
 turbodesign/arrayfuncs.py,sha256=GHIlTyLfeNsNCQQoh5m1aXK3iyvU6RjdYQipkqpU_ps,519
-turbodesign/bladerow.py,sha256=F94KAARzGd4edOgs2Cd6dSRteyYCR5U45687anYY-As,24042
+turbodesign/bladerow.py,sha256=Ie3TDxaLzOSM38dQ0xNyjFEwHWbHXMq1FcksTVEvkqc,24540
 turbodesign/cantera_gas/co2.yaml,sha256=M2o_RzxV9B9rDkgkXJC-l3voKraFZguTZuKKt4F7S_c,887
 turbodesign/compressorspool.py,sha256=z8ZVczJ-EdZvIqqZArC6UdwC5MbU2SZh_MT2CGq5avY,2600
 turbodesign/coolant.py,sha256=nuj7ryUXuBhuOPt2jHjHwtEM_LVno7A8Wm14P0lJn-8,436
@@ -20,14 +20,14 @@ turbodesign/loss/turbine/kackerokapuu.py,sha256=hUmZdyA1hAhN3_xbwBhka2dyk0Aq9rqq
 turbodesign/loss/turbine/traupel.py,sha256=aZxFE9JDcCfi1gy-fqS1SxjjlhuDG-H-g3LPurty1M0,4164
 turbodesign/lossinterp.py,sha256=B2KEobp-nD9jwD6UINgBmTlH9kKyWg3UNvXxqfUsr-k,6198
 turbodesign/outlet.py,sha256=SwTwoL6XnWlsrE5A6wLxu3qXkydDDUsdKKeBbJm4mrQ,2069
-turbodesign/passage.py,sha256=LVX9Ige4WwvSUrLH4G2Crw0DyWEiDK81a66_iNEa05Y,7597
-turbodesign/radeq.py,sha256=4unpFad6hvgaYwYLBNI8o9bszyvoNiizYjMqRX0Mjcc,10012
+turbodesign/passage.py,sha256=eZGaB5Gq9Frm80TTDJaLm1TxJV2-_fHHIeqjPuvtb8E,9550
+turbodesign/radeq.py,sha256=RCsiQzcHvR5dozK6XG0eysAhXYewF0BY_qX0f1knURo,10091
 turbodesign/rotor.py,sha256=tHl9o5H4aQ6Etd4gqa8Ime1UK7k0de4GLt5Yb1sJdGs,1376
 turbodesign/solve_radeq.py,sha256=2VGzFSVkyN0rTPFHaCQiD3v166cdEs39x7x7RuzLgmw,1886
-turbodesign/spool.py,sha256=x0o1tQKxOlV2ZRtdx-I24FidnEDpdrvjCThahd9s0Sc,13960
+turbodesign/spool.py,sha256=h4m--HR5g8o01Kkhl4Mbvx7WORQez3YpncDE7XxbNaw,14172
 turbodesign/stage.py,sha256=UP45sDKDLsAkO_WfDWJ6kqXU7cYKh_4QO01QZnSN1oQ,166
-turbodesign/td_math.py,sha256=10nPvAnLdXq8cRG8k27rZZ3fUew8hJkeBsbX4EA2xG0,17396
-turbodesign/turbinespool.py,sha256=s9cZpK9245pjUYI5hOo81SsO8UqG-TVUJlSN7SQu7yw,25877
-turbo_design-1.0.11.dist-info/METADATA,sha256=jha8nSuwVylWqH-ShW2qXTiFIYb5NAeiGOzvtS8_l4M,735
-turbo_design-1.0.11.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-turbo_design-1.0.11.dist-info/RECORD,,
+turbodesign/td_math.py,sha256=En8g8AcldaZN9qmG33wrt2EuTqKfSQ8UO2PWod6a0IE,15970
+turbodesign/turbinespool.py,sha256=U_TMv5XNTlRWP9NJWTaaFWfNeTEGEuSVWt3HDi8QyFI,26124
+turbo_design-1.1.1.dist-info/METADATA,sha256=C1hmGnuG5wJahAn1UDbHQPQCwfUeGK4Mx3XgwGucUHg,734
+turbo_design-1.1.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+turbo_design-1.1.1.dist-info/RECORD,,

turbodesign/bladerow.py

@@ -97,6 +97,8 @@ class BladeRow:
     phi:npt.NDArray = field(default_factory=lambda: np.array([0]))                      # Inclination angle x,r plane. AY td2.f
     rm: npt.NDArray = field(default_factory=lambda: np.array([0]))                      # Curvature
     incli_curve_radii: npt.NDArray = field(default_factory=lambda: np.array([0]))       # radius at which curvature was evaluated
+    mprime:npt.NDArray = field(default_factory=lambda: np.array([0]))                   # Mprime distance
+    axial_chord:float = 0
     
     Yp: float = 0                   # Pressure loss
     power:float = 0                 # Watts 
@@ -104,7 +106,8 @@ class BladeRow:
     P0_P:float = 0                  # Total to Static Pressure Ratio 
     Power_Type:PowerType
     euler_power:float = 0
-
+    Reynolds:float = 0
+    
     # Used for loss calculations
     _blade_to_blade_gap:float = 0.025 # Gap between blade in terms of percent chord.
     
@@ -117,8 +120,8 @@ class BladeRow:
     _te_s:float = 0.08
     _tip_clearance:float = 0 # Clearance as a percentage of span or blade height
 
-    _inlet_to_outlet_pratio = [0.06,0.7]
-        
+    _inlet_to_outlet_pratio = [0.06,0.95]
+    
     @property
     def inlet_to_outlet_pratio(self) -> Tuple[float,float]:
         """This is what is varied by the optimization. 
@@ -432,7 +435,10 @@ class BladeRow:
             val (float): new trailing edge to pitch ratio
         """
         self._te_s = val
-        
+    
+    def __repr__(self):
+        return f"{self.row_type.name:0.2f}' P0:{np.mean(self.P0):0.2f} T0:{np.mean(self.T0):0.2f} P:{np.mean(self.P):0.2f} massflow:{self.total_massflow_no_coolant}:0.3f"
+    
     def to_dict(self):
         
         data = {
@@ -471,6 +477,7 @@ class BladeRow:
             "P":self.P.tolist(),
             "T":self.T.tolist(),
             "rho":self.rho.tolist(),
+            "mu":self.mu,
             "Yp":self.Yp,
             "Power":self.power,
             "P0_P": self.P0_P,
@@ -479,7 +486,10 @@ class BladeRow:
             "euler_power":self.euler_power,
             "axial_chord":self.axial_chord,
             "aspect_ratio":self.aspect_ratio,
-            "area": self.area
+            "area": self.area,
+            "mprime":self.mprime[-1],
+            "Reynolds":self.Reynolds,
+            "axial_chord":self.axial_chord
         }
 
         return data

turbodesign/passage.py

@@ -104,26 +104,42 @@ class Passage:
 
         """
         phi = np.zeros(shape=x_streamline.shape)
-        rm = phi.copy()
-        r  = phi.copy()
-            
-        d_dx = FinDiff(0,x_streamline,1)
-        d2_dx2 = FinDiff(0,x_streamline,2)
-        dr_dx = d_dx(r_streamline)
-        d2r_dx2 = d2_dx2(r_streamline)    
+        r  = np.zeros(shape=x_streamline.shape)
+        radius_curvature = np.zeros(shape=x_streamline.shape)
+        # Have to make sure there isn't a divide by zero which could happen if there is a vertical line somewhere
+        indices = np.where(np.abs(np.diff(x_streamline))>np.finfo(float).eps)[0]
+    
+        d_dx = FinDiff(0,x_streamline[indices[0]:indices[-1]],1)
+        d2_dx2 = FinDiff(0,x_streamline[indices[0]:indices[-1]],2)
+        dr_dx = d_dx(r_streamline[indices[0]:indices[-1]])
+        d2r_dx2 = d2_dx2(r_streamline[indices[0]:indices[-1]])    
             
-        radius_curvature = np.power((1+np.power(dr_dx,2)),1.5)
-        radius_curvature = np.divide(radius_curvature, np.abs(d2r_dx2))
+        radius_curvature[indices[0]:indices[-1]] = np.power((1+np.power(dr_dx,2)),1.5)
+        radius_curvature[indices[0]:indices[-1]] = np.divide(radius_curvature[indices[0]:indices[-1]], np.abs(d2r_dx2))
         radius_curvature = np.nan_to_num(radius_curvature,nan=0)
         
+        def vertical_line_phi(start:int,end:int):
+            # Lets get the phi and slope for the vertical parts 
+            for i in range(start,end):     
+                dx = x_streamline[i] - x_streamline[i-1]
+                dr = r_streamline[i] - r_streamline[i-1]
+                if (dr < 0) & (np.abs(dx) < np.finfo(float).eps):
+                    phi[i-1] = -np.pi/2
+                elif (dr > 0) & (np.abs(dx) < np.finfo(float).eps):
+                    phi[i-1] = np.pi/2
+                radius_curvature[i-1] = 1000000 # Initialize to high number, used in radeq. 
+                
+        vertical_line_phi(1,indices[0])
+        vertical_line_phi(indices[1],len(x_streamline))
+        
         rm = radius_curvature     # https://www.cuemath.com/radius-of-curvature-formula/ should be 1/curvature
-        phi = np.arctan(dr_dx)
+        phi[indices[0]:indices[-1]] = np.arctan(dr_dx)
         r = r_streamline
             
         return phi, rm, r
         
     def get_cutting_line(self, t_hub:float) -> line2D:
-        """Gets the cutting line between hub and shroud 
+        """Gets the cutting line perpendicular to hub and shroud 
 
         Args:
             t_hub (float): percentage along the axial direction 
@@ -168,6 +184,27 @@ class Passage:
         rshroud = self.rshroud(t_shroud)
         return line2D([xhub,rhub],[xshroud,rshroud]), t_hub, t_shroud
     
+    def get_xr_slice(self,t_span:float,axial_location:float):
+        """Returns the xr coordinates of a streamline, a line that is parallel to both hub and shroud
+            
+        Args:
+            t_span (float): _description_
+            axial_location (float): _description_
+
+        Returns:
+            np.NDArray: _description_
+        """
+        t_hub = np.linspace(0,axial_location,100)
+        
+        shroud_pts_cyl = np.vstack([self.xshroud(t_hub),self.rshroud(t_hub)]).transpose()
+        hub_pts_cyl = np.vstack([self.xhub(t_hub),self.rhub(t_hub)]).transpose()
+        n = len(t_hub)
+            
+        xr = np.zeros((n,2))
+        for j in range(n):
+            l = line2D(hub_pts_cyl[j,:],shroud_pts_cyl[j,:])
+            xr[j,0],xr[j,1] = l.get_point(t_span)
+        return xr
         
     @property
     def hub_length(self):

turbodesign/radeq.py

@@ -52,12 +52,12 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
         gamma = row.gamma
 
         # Solve the Radial Equlibrium 
-        Vt = Vm*np.cos(phi)*np.tan(alpha)
+        Vt = Vm*np.tan(alpha)
         Vr = Vm*np.sin(phi)
         # Estimations 
         dVm_dr = float(interp1d(row_radius, np.gradient(row.Vm, row_radius))(r))
-        dVt_dr = dVm_dr*np.cos(phi)*np.tan(alpha)
-        dVr_dr = 0 #dVm_dr*np.sin(phi)
+        dVt_dr = dVm_dr*np.tan(alpha)
+        dVr_dr = dVm_dr*np.sin(phi)
 
         # Upstream 
         dT0up_dr = float(interp1d(upstream.percent_hub_shroud, np.gradient(upstream.T0,up_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) # use percentage to get the T0 upstream value
@@ -74,7 +74,9 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
         # if row.loss_function.LossType == LossType.Pressure: # type: ignore
         #     dP0_dr = dP0up_dr-row.Yp*(dP0up_dr - dP_dr)     # Eqn 9
 
-        C = Vm**2*(1+np.cos(phi)**2 * np.tan(alpha)**2)/(2*Cp*T0)
+        C = Vm**2*(1+np.tan(alpha)**2)/(2*Cp*T0)
+        if (C>1) & ((gamma/(gamma-1))<2):
+            raise Exception("Invalid value of C {C}, change reduce alpha or Vm")
         B = (1-C)**(gamma/(gamma-1))      
         A = P0 * gamma/(gamma-1) * (1-C)**(1/(gamma-1))
         dVm_dr = 1/(2*Vm*A) * (rho*(Vt/r - Vm**2/rm * np.cos(phi) - Vr*dVr_dr) - dP0_dr*B) + 1/(2*T0) *dT0_dr  # Eqn 6

turbodesign/spool.py

@@ -251,7 +251,7 @@ class Spool:
             plt.figure(num=1,clear=True)
             for i in range(1,len(self.blade_rows)-1): # Don't plot inlet or outlet 
                 row = self.blade_rows[i]
-                x_end = x_start + row.Vx.mean()
+                x_end = x_start + row.Vm.mean()
                 dx = x_end - x_start
                 
                 Vt = row.Vt[j]
@@ -287,9 +287,15 @@ class Spool:
                     plt.annotate("", xy=(x_end,Wt+U), xytext=(x_end,Wt), arrowprops=prop) # U
                     plt.text(x_end+dx*0.1,Wt+U/2,"U",fontdict={"fontsize":"xx-large"})
 
-                plt.text((x_start+x_end)/2,-y_max*0.95,row.row_type.name,fontdict={"fontsize":"xx-large"})
-                x_start += row.Vx[j]
+                if -np.sign(Vt)>0:
+                    y = y_min 
+                else:
+                    y = y_max
+                plt.text((x_start+x_end)/2,-np.sign(Vt)*y*0.95,row.row_type.name,fontdict={"fontsize":"xx-large"})
+                x_start += row.Vm[j]
                 plt.axis([0,x_end+dx, y_min, y_max])
+            plt.ylabel("Tangental Velocity [m/s]")
+            plt.xlabel("Vm [m/s]")
             plt.title(f"Velocity Triangles for Streamline {j}")
             plt.savefig(f"streamline_{j:04d}.png",transparent=False,dpi=150)
     

turbodesign/td_math.py

@@ -5,6 +5,7 @@ import numpy.typing as npt
 from .bladerow import BladeRow, compute_gas_constants
 from .enums import RowType, LossType
 from scipy.integrate import trapezoid
+from .passage import Passage
 
 def T0_coolant_weighted_average(row:BladeRow) -> float:
     """Calculate the new weighted Total Temperature array considering coolant
@@ -78,6 +79,33 @@ def compute_massflow(row:BladeRow) -> None:
     row.calculated_massflow = massflow[-1]
     row.area = total_area
 
+def compute_reynolds(rows:List[BladeRow],passage:Passage):
+    """Calculates the Reynolds Number 
+
+    Args:
+        rows (List[BladeRow]): Blade row to calculate the Reynolds number
+        passage (Passage): Passage 
+    """
+    for row in rows:
+        xr = passage.get_xr_slice(0.5,row.axial_location)
+        dx = np.diff(xr[:,0])
+        dr = np.diff(xr[:,1])
+        c = np.sum(np.sqrt(dx**2+dr**2))
+        mp = [2/(xr[i,1]+xr[i-1,1])*np.sqrt(dr[i-1]**2 + dx[i-1]**2) for i in range(1,len(xr[:,1]))]
+        mp = np.hstack([[0],np.cumsum(mp)])
+        
+        if row.row_type == RowType.Rotor:
+            V = row.W.mean()
+        else:
+            V = row.V.mean()
+        rho = row.rho.mean()
+        mu = row.mu
+        row.Reynolds = c*V*rho/mu
+        row.mprime = mp
+        row.axial_chord = c
+
+
+    
 def compute_power(row:BladeRow,upstream:BladeRow) -> None:
     """Calculates the power
 
@@ -169,56 +197,6 @@ def compute_quantities(row:BladeRow,upstream:BladeRow):
         row.T0R = row.T + row.W**2 / (2*row.Cp)
         row.P0R = row.P*(row.T0R/row.T)**((row.gamma)/(row.gamma-1))
    
-def compute_quantities_power(row:BladeRow,upstream:BladeRow):
-    """Calculation of all quantites after radial equilibrium has been solved assuming we know the power at the exit
-        
-    Note:
-        Radial Equilibrium gives P0, T0, Vm. This code assumes the loss either enthalpy or pressure loss has already been calculated 
-
-        compute_velocity has been called so we know W, Wt, V, Vt, U, M, M_rel
-
-        Static Pressure and Temperature should come from Total Temperature and Pressure + Velocity 
-
-    Args:
-        row (BladeRow): current blade row. All quantities are at exit
-        upstream (BladeRow): upstream blade row. All quantities are at exit
-
-    """
-    if row.row_type == RowType.Rotor:
-        Cp_avg = (row.Cp+upstream.Cp)/2
-        row.T0R = upstream.T0R - T0_coolant_weighted_average(row) - (upstream.U**2-row.U**2)/(2*Cp_avg)
-
-        # Factor in T0R_drop. Convert T0R drop to absolute terms
-        T_drop = (upstream.T0R - row.T0R) - row.W**2/(2*row.Cp) # row.T0R contains the drop
-        T0_drop = T_drop*(1+(row.gamma-1)/2*row.M**2)
-
-        # Adjust Total Temperature to match power
-        T0 = upstream.T0 - row.power/row.eta_total/(row.total_massflow*row.Cp) + T0_drop
-
-        if row.loss_function == LossType.Pressure: 
-            row.P0R = upstream.P0R - row.Yp*(upstream.P0R-row.P)
-            row.T0 = T0
-            row.T = row.T0/(1+(row.gamma-1)/2*row.M**2) 
-            row.P = row.P0R*(row.T/row.T0R)**(row.gamma/(row.gamma-1))
-            
-        elif row.loss_function == LossType.Enthalpy:                
-            row.P0 = row.P*(T0/row.T)**(row.gamma/(row.gamma-1))
-            row.T = T0 - row.W**2/(2*row.Cp) + T_drop
-            row.T0 = T0
-            row.P = row.P0*(row.T0/row.T)**(row.gamma/(row.gamma-1))
-            row.P0R = row.P * (row.T0R/row.T)**((row.gamma)/(row.gamma-1))
-
-    elif row.row_type == RowType.Stator:        
-        row.T0 = upstream.T0 - T0_coolant_weighted_average(row)
-        if row.loss_function == LossType.Pressure:
-            row.P0 = upstream.P0 - row.Yp*(upstream.P0-row.P)
-        else:
-            row.P0 = upstream.P0
-        row.T = row.T0 * (1+(row.gamma-1)/2*row.M**2)
-        row.P = row.P0 * (row.T/row.T0)**((row.gamma)/(row.gamma-1))
-        row.T0R = row.T + row.W**2 / (2*row.Cp)
-        row.P0R = row.P*(row.T0R/row.T)**((row.gamma)/(row.gamma-1))
-
 def stator_calc(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None,calculate_vm:bool=True):
     """Given P0, T0, P, alpha2 of stator calculate all other quantities
 
@@ -255,21 +233,18 @@ def stator_calc(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None,calculat
         row.T0 = upstream.T0 - T0_coolant_weighted_average(row)
         row.T = row.T0/T0_T
         row.V = row.M*np.sqrt(row.gamma*row.R*row.T)
-        VV = row.V*np.cos(row.phi)
-        row.Vx = VV*np.cos(row.alpha2)
-        row.Vt = VV*np.sin(row.alpha2)
+        row.Vx = row.Vm*np.cos(row.phi)
         row.Vr = row.V*np.sin(row.phi)
         row.Vm = np.sqrt(row.Vx**2+row.Vr**2)
-    else: # We know Vm, P0, T0
+        row.Vt = row.Vm*np.tan(row.alpha2)
+    else: # We know Vm, P0, T0, P
         row.Vx = row.Vm*np.cos(row.phi)
         row.Vr = row.Vm*np.sin(row.phi)
-        row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)
+        row.Vt = row.Vm*np.tan(row.alpha2)
         row.V = np.sqrt(row.Vx**2 + row.Vr**2 + row.Vt**2)
-        for _ in range(3): # Mach is a function of T and T is a function of Mach
-            row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
-            T0_T = (1+(row.gamma-1)/2 * row.M**2)
-            row.P = row.P0 *(1/T0_T)**(row.gamma/(row.gamma-1))
-            row.T = row.T0 * (1/T0_T)
+        
+        row.T = row.P/(row.R*row.rho)   # We know P, this is a guess
+        row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
         
     if upstream.row_type == RowType.Rotor:
         row.alpha1 = upstream.alpha2 # Upstream rotor absolute frame flow angle
@@ -297,13 +272,14 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
     upstream.U = upstream.rpm*np.pi/30 * upstream_radius # rad/s 
     upstream.Wt = upstream.Vt - upstream.U
     upstream.W = np.sqrt(upstream.Vx**2 + upstream.Wt**2 + upstream.Vr**2)
-    upstream.beta2 = np.arctan2(upstream.Wt,upstream.Vx)
+    upstream.beta2 = np.arctan2(upstream.Wt,upstream.Vm)
     upstream.T0R = upstream.T+upstream.W**2/(2*upstream.Cp)
     upstream.P0R = upstream.P * (upstream.T0R/upstream.T)**((upstream.gamma)/(upstream.gamma-1))      
     upstream.M_rel = upstream.W/np.sqrt(upstream.gamma*upstream.R*upstream.T)
     
     upstream_rothalpy = upstream.T0R*upstream.Cp - 0.5*upstream.U**2 # H01R - 1/2 U1^2 
-
+    if np.any(upstream_rothalpy < 0):
+        print('U is too high, reduce RPM or radius')
     # Rotor Exit Calculations
     row.beta1 = upstream.beta2
     #row.Yp # Evaluated earlier 
@@ -320,26 +296,26 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
             # Need to adjust T
             print(f'nan detected: check flow path. Turbine inlet cut should be horizontal')
         row.Vr = row.W*np.sin(row.phi)
-        row.Wt = np.sqrt(row.W**2 - row.Vr**2) * np.sin(row.beta2)
+        row.Vm = row.W*np.cos(row.beta2)
+        row.Wt = row.W*np.sin(row.beta2)
+        row.Vx = row.Vm*np.cos(row.phi)
         row.Vt = row.Wt + row.U 
-        ww = row.W*np.cos(row.phi)
-        row.Vx = ww*np.cos(row.beta2)
         row.V = np.sqrt(row.Vr**2+row.Vt**2+row.Vx**2)
         row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
         row.Vm = np.sqrt(row.Vx**2+row.Vr**2)
         row.T0 = row.T + row.V**2/(2*row.Cp)
         row.P0 = row.P*(row.T0/row.T)**(row.gamma/(row.gamma-1))
-        row.alpha2 = np.arctan2(row.Vt,row.Vx)
+        row.alpha2 = np.arctan2(row.Vt,row.Vm)
     else: # We know Vm, P0, T0
         row.Vr = row.Vm*np.sin(row.phi)
         row.Vx = row.Vm*np.cos(row.phi)
         
         row.W = np.sqrt(2*row.Cp*(row.T0R-row.T))
-        row.Wt = np.sqrt(row.W**2 - row.Vr**2) * np.sin(row.beta2) 
+        row.Wt = row.W*np.sin(row.beta2)
         row.U = row.omega * row.r 
         row.Vt = row.Wt+row.U
         
-        row.alpha2 = np.arctan2(row.Vt,row.Vx)
+        row.alpha2 = np.arctan2(row.Vt,row.Vm)
         row.V = np.sqrt(row.Vx**2 + row.Vr**2 + row.Vt**2)
         
         row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
@@ -366,7 +342,7 @@ def inlet_calc(row:BladeRow):
     row.P = row.P0 
     row.rho = row.P/(row.T*row.R)
     total_area = 0 
-    for _ in range(5): # Lets converge the Mach and Total and Static pressures
+    for iter in range(5): # Lets converge the Mach and Total and Static pressures
         for j in range(1,len(row.percent_hub_shroud)):
             rho = row.rho[j]
             tube_massflow = row.massflow[j]-row.massflow[j-1]
@@ -380,6 +356,11 @@ def inlet_calc(row:BladeRow):
                 area[j] = 2*np.pi*C*(S/2*dx**2+row.r[j-1]*dx)
                 total_area += area[j]
                 row.Vm[j] = tube_massflow/(rho*area[j])
+        avg_mach = np.mean(row.M)
+        if np.mean(row.M)>0.5:
+            print(f"High inlet mach can lead to errors iter:{iter} Mach:{avg_mach}")
+        if np.mean(row.M)<0.01:
+            print(f"Unusually slow flow:{iter} Mach:{avg_mach}")
         row.Vm[0] = 1/(len(row.Vm)-1)*row.Vm[1:].sum() # Initialize the value at the hub to not upset the mean
         row.Vr = row.Vm*np.sin(row.phi)
         row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)

turbodesign/turbinespool.py

@@ -8,7 +8,7 @@ from .passage import Passage
 from scipy.interpolate import interp1d
 import numpy as np
 import numpy.typing as npt
-from .td_math import inlet_calc,rotor_calc, stator_calc, compute_massflow, compute_power, compute_gas_constants
+from .td_math import inlet_calc,rotor_calc, stator_calc, compute_massflow, compute_power, compute_gas_constants, compute_reynolds
 from .solve_radeq import adjust_streamlines, radeq
 from scipy.optimize import minimize_scalar, minimize, fmin_slsqp
 from .inlet import Inlet
@@ -136,7 +136,7 @@ class TurbineSpool(Spool):
             self.__match_massflow()
         elif self.massflow_constraint == MassflowConstraint.BalanceMassFlow:
             self.__balance_massflow()
-    
+
     
     def __match_massflow(self):
         """ Matches the massflow between streamtubes by changing exit angles. Doesn't use radial equilibrium.
@@ -171,10 +171,11 @@ class TurbineSpool(Spool):
                             row.alpha2[0] = 1/(len(row.alpha2)-1)*row.alpha2[1:].sum()
                     upstream = compute_gas_constants(upstream)
                     row = compute_gas_constants(row)
-                    
+                
                     
             # Step 3: Adjust streamlines to evenly divide massflow
             adjust_streamlines(self.blade_rows,self.passage)
+        compute_reynolds(self.blade_rows,self.passage)
             
     def __balance_massflow(self):
         """ Balances the massflow between rows. Use radial equilibrium.
@@ -206,7 +207,9 @@ class TurbineSpool(Spool):
                             sign*=-1
                 if len(stage_ids) % 2 == 1:
                     massflow_stage.append(massflow_stage[-1]*sign)
-                
+            deviation = np.std(total_massflow)*2
+            if deviation>1.0:
+                print("high massflow deviation detected")
             return np.std(total_massflow)*2 # + abs(sum(massflow_stage))  # Equation 28
             
         # Balance the massflow between Stages
@@ -229,27 +232,27 @@ class TurbineSpool(Spool):
             Returns:
                 _type_: _description_
             """
-            try:
-                if balance_mean_pressure:
-                    for j in range(self.num_streamlines):                
-                        Ps_range = outlet_pressure(x0,P0[j],P[j])
-                        for i in range(1,len(blade_rows)-1):
-                            blade_rows[i].P[j] = Ps_range[i-1]
-                    blade_rows[-1].P = P
-                else:
+            # try:
+            if balance_mean_pressure:
+                for j in range(self.num_streamlines):                
+                    Ps_range = outlet_pressure(x0,P0[j],P[j])
                     for i in range(1,len(blade_rows)-1):
-                        for j in range(self.num_streamlines):
-                            blade_rows[i].P[j] = P[j]*x0[(i-1)*self.num_streamlines+j]    # x0 size = num_streamlines -1 
-                    
-                calculate_massflows(blade_rows,True)
-                print(x0)
-                return calculate_error(blade_rows)
-            except:
+                        blade_rows[i].P[j] = Ps_range[i-1]
+                blade_rows[-1].P = P
+            else:
                 for i in range(1,len(blade_rows)-1):
                     for j in range(self.num_streamlines):
-                        blade_rows[i].P[j] = P[j]
-                calculate_massflows(blade_rows,True)
-                return 10
+                        blade_rows[i].P[j] = P[j]*x0[(i-1)*self.num_streamlines+j]    # x0 size = num_streamlines -1 
+                
+            calculate_massflows(blade_rows,True)
+            print(x0)
+            return calculate_error(blade_rows)
+            # except:
+            #     for i in range(1,len(blade_rows)-1):
+            #         for j in range(self.num_streamlines):
+            #             blade_rows[i].P[j] = P[j]
+            #     calculate_massflows(blade_rows,True)
+            #     return 10
         # Break apart the rows to stages
         outlet_P=list(); outlet_P_guess = list() # Outlet P is the bounds, outlet_p_guess is the guessed values 
         
@@ -282,7 +285,10 @@ class TurbineSpool(Spool):
             self.blade_rows[-1].P = self.blade_rows[-1].get_static_pressure(self.blade_rows[-1].percent_hub_shroud)
         err = calculate_error(self.blade_rows[:-1])
         print(f"Massflow convergenced error:{err}")
-            
+        
+        # calculate Reynolds number
+        compute_reynolds(self.blade_rows,self.passage)
+        
         # finetune = True
         # if finetune:        
         #     print('Finetune static pressure between stages')
@@ -451,7 +457,7 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
                     row = compute_gas_constants(row)
                     compute_massflow(row)
                     compute_power(row,upstream)
-
+    
 def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:BladeRow,downstream:BladeRow=None):
     """Finds the blade exit angles that balance the massflow throughout the stage 
 
@@ -534,11 +540,11 @@ def outlet_pressure(percents:List[float],inletP0:float,outletP:float) -> npt.NDA
     maxP = inletP0
     minP = outletP
     if isinstance(percents, float):
-        Ps = [percents*(minP-maxP)+maxP]
+        Ps = [percents*(maxP-minP)+minP]
     else:
         Ps = np.zeros(shape=(len(percents),1)); i = 0
         for p in percents:
-            Ps[i] = p*(minP-maxP)+maxP
+            Ps[i] = p*(maxP - minP) + minP
             maxP = Ps[i]
             i+=1
     return Ps