turbo-design 1.3.0__tar.gz → 1.3.2__tar.gz

{turbo_design-1.3.0 → turbo_design-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: turbo-design
-Version: 1.3.0
+Version: 1.3.2
 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.3.0 → turbo_design-1.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "turbo-design"
-version = "1.3.0"
+version = "1.3.2"
 description = "TurboDesign is a library used to design turbines and compressors using radial equilibrium."
 authors = ["Paht Juangphanich <paht.juangphanich@nasa.gov>"]
 packages = [

turbo_design-1.3.2/turbodesign/radeq.py

@@ -0,0 +1,160 @@
+from scipy.interpolate import interp1d,PchipInterpolator
+from scipy.integrate import solve_ivp
+import numpy as np  
+import numdifftools as nd 
+from .bladerow import BladeRow
+from .enums import RowType
+import math 
+
+def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
+    """Solves the radial equilibrium equation for axial machines and returns the convergence. 
+
+    Note:
+        This function will give you T0, P0, Vm as a function of the radius. 
+        
+    Args:
+        row (BladeRow): Current row
+        upstream (BladeRow): Previous row
+        downstream (BladeRow): Next row
+        
+    Returns:
+        BladeRow: current row with T0, P0, and Vm calculated
+    """
+    row_radius = row.r     # Use these for gradient 
+    up_radius = upstream.r
+        
+    def ode_radeq_streamtube(r:np.ndarray,y:np.ndarray):
+        """Solves the radial equilibrium equation for a streamtube 
+
+        Args:
+            r (np.ndarray): radius not as a percent
+            y (np.ndarray): Array containing [P0,Vt,VtU,T0]
+            
+        """
+        P0 = y[0]
+        T0 = y[1]
+        Vm = y[2]
+        r = row.r.mean()+r
+        if r>row_radius[-1]:
+            return [0,0,0]
+        elif r<row_radius[0]:
+            return [0,0,0]
+
+        Cp = row.Cp
+        phi = interp1d(row_radius, row.phi)(r)
+        alpha = interp1d(row_radius, row.alpha2)(r)
+        T = interp1d(row_radius, row.T)(r)
+        P = interp1d(row_radius, row.P)(r)
+        rm = interp1d(row_radius, row.rm)(r)
+        rho = row.rho.mean()
+        
+        if (row.row_type == RowType.Rotor):
+            omega = row.rpm*np.pi/30
+            U = omega*r
+        else:
+            omega = 0
+            U = 0
+        gamma = row.gamma
+
+        # Solve the Radial Equlibrium 
+        Vt = Vm*np.tan(alpha)
+        Vr = Vm*np.sin(phi)
+        # Estimations 
+        dVm_dr = float(interp1d(row_radius, np.gradient(row.Vm, row_radius))(r))        
+        up_Vm = interp1d(row_radius, upstream.Vm)(r)
+        
+        if downstream:
+            if downstream.row_type == RowType.Outlet:
+                down_Vm = Vm
+            else:
+                down_Vm = interp1d(row_radius, downstream.Vm)(r)
+        else:
+            down_Vm = Vm
+        up_m = interp1d(row_radius, upstream.m)(r)
+        
+        # Get a rough guess of dVm/dm
+        if downstream!=None:
+            down_m = interp1d(row_radius, downstream.m)(r)
+            row_m = interp1d(row_radius, row.m)(r)
+            if down_m != row_m:
+                func_Vm_m = PchipInterpolator([up_m, row_m, down_m],[up_Vm, Vm, down_Vm])
+            else:
+                func_Vm_m = PchipInterpolator([up_m, row_m],[up_Vm, Vm])    
+        else:
+            func_Vm_m = PchipInterpolator([up_m, row_m],[up_Vm, Vm])    
+        dVm_dm = func_Vm_m.derivative()(row_m)
+        
+        # Upstream 
+        dT_dr = float(interp1d(row_radius, np.gradient(row.T,row_radius))(r))
+        dP_dr = float(interp1d(row_radius, np.gradient(row.P,row_radius))(r))
+        P = float(interp1d(row_radius, np.gradient(row.P,row_radius))(r))
+        dT0_dr = dT_dr + Vm/Cp * (1 + np.tan(alpha)**2)*dVm_dr 
+        dP0_dr = dP_dr * (T0/T)**(gamma/(gamma-1)) + P*gamma/(gamma-1) * (T0/T)**(1/(gamma-1)) * (T*dT0_dr-T0*dT_dr)/T**2
+        # dT0_dr = float(interp1d(row.percent_hub_shroud, np.gradient(row.T0,row_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) 
+        # dP0_dr = float(interp1d(row.percent_hub_shroud, np.gradient(row.P0,row_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) 
+        
+        C = (1 + np.tan(alpha)**2) * Vm**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)) * (1 + np.tan(alpha)**2)/(2*Cp)
+        
+        eqn15_rhs = Vt**2/r - Vm**2/rm*np.sin(phi) - Vr*dVm_dm # right hand side of equation 15
+        eqn15_rhs_simple = Vt**2/r # right hand side of equation 15 simplified for axial machines
+        
+        epsilon = 1e-10  # or another small threshold
+        if abs(rm) > epsilon:
+            dVm_dr = T0/(2*Vm*A) * (rho*eqn15_rhs - B*dP0_dr) + Vm/(2*T0) * dT0_dr # Eqn 21
+        else:
+            dVm_dr = T0/(2*Vm*A) * (rho*eqn15_rhs_simple - B*dP0_dr) + Vm/(2*T0) * dT0_dr  # Eqn 21, simple 
+        
+        ydot = np.array([dP0_dr,dT0_dr,dVm_dr])
+
+        return ydot
+
+    T0 = row.T0
+    
+    P0 = row.P0
+    Vm = row.Vm
+
+    # Estimate the Vt based on a given turning angle 
+    mean_radius = row_radius.mean()
+    tip_radius = row_radius.max()
+    hub_radius = row_radius.min()
+
+    T0m = interp1d(row.percent_hub_shroud,T0)(0.5); 
+    P0m = interp1d(row.percent_hub_shroud,P0)(0.5); Vmm = interp1d(row.percent_hub_shroud,Vm)(0.5)
+    # We are solving for the values of these quantities at row exit
+    ics = np.array([P0m,T0m,Vmm])
+
+    # hub_to_tip = np.linspace(hub_radius,tip_radius)
+    # res = odeint(ode_radeq_streamtube, ics, hub_to_tip, tfirst=True)
+    
+    # P0_new = interp1d(hub_to_tip,res[:,0])(row_radius)
+    # T0_new = interp1d(hub_to_tip,res[:,1])(row_radius)
+    # Vm_new = interp1d(hub_to_tip,res[:,2])(row_radius)
+    
+    # mean_radius_to_tip = np.linspace(0,tip_radius-mean_radius,len(row_radius)*5)
+    res1 = solve_ivp(ode_radeq_streamtube, t_span =[0, tip_radius-mean_radius], y0 = ics)
+    
+    # mean_radius_to_hub = np.linspace(0,hub_radius-mean_radius,len(row_radius)*5)
+    res2 = solve_ivp(ode_radeq_streamtube, t_span = [hub_radius-mean_radius,0], y0 = ics)
+    
+    mid_to_tip_vals = res1.y.transpose()
+    mid_to_tip_r = res1.t + mean_radius
+    mid_to_hub_vals = res2.y.transpose()
+    mid_to_hub_r = res2.t + mean_radius
+    mid_to_hub_vals = np.flipud(mid_to_hub_vals)
+    hub_to_tip_vals = np.concatenate([mid_to_hub_vals[:-1,:],mid_to_tip_vals])
+    
+    r = np.concatenate([mid_to_hub_r[:-1], mid_to_tip_r])
+    
+    P0_new = interp1d(r,hub_to_tip_vals[:,0])(row_radius)
+    T0_new = interp1d(r,hub_to_tip_vals[:,1])(row_radius)
+    Vm_new = interp1d(r,hub_to_tip_vals[:,2])(row_radius)
+    
+    row.P0 = P0_new
+    row.T0 = T0_new
+    row.Vm = Vm_new
+    return row
+

{turbo_design-1.3.0 → turbo_design-1.3.2}/turbodesign/solve_radeq.py

@@ -1,5 +1,5 @@
 from typing import List, Tuple
-from .radeq import radeq, radeq_normalized
+from .radeq import radeq
 from .enums import LossType, RowType, PowerType, MassflowConstraint
 from .bladerow import BladeRow
 from .td_math import compute_gas_constants

{turbo_design-1.3.0 → turbo_design-1.3.2}/turbodesign/td_math.py

@@ -296,7 +296,7 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
     row.P0R = upstream.P0R - row.Yp*(upstream.P0R-row.P)
     
     # Total Relative Temperature stays constant through the rotor. Adjust for change in radius from rotor inlet to exit
-    row.T0R = (upstream_rothalpy + 0.5*row.U**2)/row.Cp - T0_coolant_weighted_average(row) 
+    row.T0R = upstream.T0R # (upstream_rothalpy + 0.5*row.U**2)/row.Cp # - T0_coolant_weighted_average(row) 
     P0R_P = row.P0R / row.P
     T0R_T = P0R_P**((row.gamma-1)/row.gamma)
     row.T = (row.T0R/T0R_T)     # Exit static temperature
@@ -326,7 +326,7 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
         row.Vt = row.Wt+row.U
         
         row.alpha2 = np.arctan2(row.Vt,row.Vm)
-        row.V = np.sqrt(row.Vx**2 + row.Vr**2 + row.Vt**2)
+        row.V = np.sqrt(row.Vm**2*(1+np.tan(row.alpha2)**2))
         
         row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
         T0_T = (1+(row.gamma-1)/2 * row.M**2)
@@ -369,7 +369,7 @@ def inlet_calc(row:BladeRow):
             raise ValueError(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)
+        row.Vt = row.Vm*np.tan(row.alpha2)
         row.V = np.sqrt(row.Vt**2+row.Vm**2)
         # Fine tune the Temperature and Pressure and density
         row.M = row.V/np.sqrt(row.gamma*row.R*row.T)

{turbo_design-1.3.0 → turbo_design-1.3.2}/turbodesign/turbinespool.py

@@ -13,6 +13,7 @@ from .solve_radeq import adjust_streamlines, radeq
 from scipy.optimize import minimize_scalar, differential_evolution, fmin_slsqp
 from .inlet import Inlet
 from .outlet import Outlet
+from pyturbo.helper import convert_to_ndarray
 
 class TurbineSpool(Spool):
     
@@ -193,7 +194,7 @@ class TurbineSpool(Spool):
         """
         total_massflow = list(); s = 0; massflow_stage = list()
         stage_ids = list(set([row.stage_id for row in blade_rows if row.stage_id>=0]))
-        for row in blade_rows[1:-1]: # Ignore inlet and outlet
+        for row in blade_rows: # Ignore inlet and outlet
             total_massflow.append(row.total_massflow_no_coolant)
             sign = 1
             for s in stage_ids:
@@ -237,7 +238,7 @@ class TurbineSpool(Spool):
                 2. Keep the mean 
 
             Args:
-                x0 (List[float]): _description_
+                x0 (List[float]): Percentage of P0 exiting each row
                 blade_rows (List[List[BladeRow]]): _description_
                 P0 (npt.NDArray): _description_
                 P (npt.NDArray): (1) Outlet Static Pressure. (2) 
@@ -250,9 +251,9 @@ class TurbineSpool(Spool):
             # try:
             if balance_mean_pressure:
                 for j in range(self.num_streamlines):
-                    Ps_range = outlet_pressure(x0,P0[j],P[j])
+                    Ps = outlet_pressure(x0,P0[j],P[j])
                     for i in range(1,len(blade_rows)-2):
-                        blade_rows[i].P[j] = Ps_range[i-1]
+                        blade_rows[i].P[j] = float(Ps[i-1])
                 blade_rows[-2].P = P
             else:
                 for i in range(1,len(blade_rows)-1):
@@ -261,7 +262,7 @@ class TurbineSpool(Spool):
             # try:  
             calculate_massflows(blade_rows,True,self.fluid)
             print(x0)
-            return self.__massflow_std__(blade_rows)
+            return self.__massflow_std__(blade_rows[1:-1]) # do not consider inlet and outlet
             # except Exception as e:
             #     print(e)
             # finally:
@@ -278,9 +279,9 @@ class TurbineSpool(Spool):
         
         print(f"Looping to converge massflow")
         past_err = -100; loop_iter = 0; err = 0.001
-        while np.abs((err-past_err)/err)>0.05:
+        while (np.abs((err-past_err)/err)>0.05) and loop_iter<10:
             if len(outlet_P) == 1:
-                # x = balance_massflows(0.658,self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P)
+                # x = balance_massflows(0.22896832148169688,self.blade_rows,self.blade_rows[0].P0,self.blade_rows[-1].P)
                 res = minimize_scalar(fun=balance_massflows,args=(self.blade_rows,self.blade_rows[0].P0,self.blade_rows[-1].P),bounds=outlet_P[0],tol=0.001,options={'disp': True},method='bounded')
                 x = res.x
                 print(x)
@@ -302,7 +303,9 @@ class TurbineSpool(Spool):
             self.blade_rows[-1].transfer_quantities(self.blade_rows[-2])
             self.blade_rows[-1].P = self.blade_rows[-1].get_static_pressure(self.blade_rows[-1].percent_hub_shroud)
             
+            past_err = err
             err = self.__massflow_std__(self.blade_rows)
+            loop_iter += 1 
             print(f"Loop {loop_iter} massflow convergenced error:{err}")
         
         # calculate Reynolds number
@@ -393,64 +396,63 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False,fluid:
         passage (Passage): _description_
         calculate_vm (bool, optional): _description_. Defaults to False.
     """
-    for p in range(3):
-        for i in range(1,len(blade_rows)-1):
-            row = blade_rows[i]
-            # Upstream Row
-            if i == 0:
-                upstream = blade_rows[i]
-            else:
-                upstream = blade_rows[i-1]
-            if i<len(blade_rows)-1:
-                downstream = blade_rows[i+1]
-            
-            # Pressure loss = shift in entropy which affects the total pressure of the row
-            if row.row_type == RowType.Inlet:
-                row.Yp = 0
-            else:
-                if row.loss_function.loss_type == LossType.Pressure:
-                    row.Yp = row.loss_function(row,upstream)
-                    for _ in range(2):
-                        if row.row_type == RowType.Rotor:
-                            rotor_calc(row,upstream,calculate_vm=True)
-                            # Finds Equilibrium between Vm, P0, T0
-                            row = radeq(row,upstream,downstream) 
-                            compute_gas_constants(row,fluid)
-                            rotor_calc(row,upstream,calculate_vm=False)
-                        elif row.row_type == RowType.Stator:
-                            stator_calc(row,upstream,downstream,calculate_vm=True)
-                            # Finds Equilibrium between Vm, P0, T0
-                            row = radeq(row,upstream,downstream)
-                            compute_gas_constants(row,fluid)
-                            stator_calc(row,upstream,downstream,calculate_vm=False)
-                        compute_gas_constants(row,fluid)
-                        compute_massflow(row)
-                        compute_power(row,upstream)
-                        
-                elif row.loss_function.loss_type == LossType.Enthalpy: 
+    for i in range(1,len(blade_rows)-1):
+        row = blade_rows[i]
+        # Upstream Row
+        if i == 0:
+            upstream = blade_rows[i]
+        else:
+            upstream = blade_rows[i-1]
+        if i<len(blade_rows)-1:
+            downstream = blade_rows[i+1]
+        
+        # Pressure loss = shift in entropy which affects the total pressure of the row
+        if row.row_type == RowType.Inlet:
+            row.Yp = 0
+        else:
+            if row.loss_function.loss_type == LossType.Pressure:
+                row.Yp = row.loss_function(row,upstream)
+                for _ in range(2):
                     if row.row_type == RowType.Rotor:
-                        row.Yp = 0
-                        rotor_calc(row,upstream,calculate_vm=calculate_vm)
-                        eta_total = float(row.loss_function(row,upstream))
-                        def find_yp(Yp,row,upstream):
-                            row.Yp = Yp
-                            rotor_calc(row,upstream,calculate_vm=True)
-                            row = radeq(row,upstream)
-                            compute_gas_constants(row,fluid)
-                            rotor_calc(row,upstream,calculate_vm=False)
-                            return abs(row.eta_total - eta_total)
-                        
-                        res = minimize_scalar(find_yp,bounds=[0,0.6],args=(row,upstream))
-                        row.Yp = res.x
+                        rotor_calc(row,upstream,calculate_vm=True)
+                        # Finds Equilibrium between Vm, P0, T0
+                        row = radeq(row,upstream,downstream) 
+                        compute_gas_constants(row,fluid)
+                        rotor_calc(row,upstream,calculate_vm=False)
                     elif row.row_type == RowType.Stator:
-                        row.Yp = 0
                         stator_calc(row,upstream,downstream,calculate_vm=True)
-                        row = radeq(row,upstream) 
-                        row = compute_gas_constants(row,fluid)
+                        # Finds Equilibrium between Vm, P0, T0
+                        row = radeq(row,upstream,downstream)
+                        compute_gas_constants(row,fluid)
                         stator_calc(row,upstream,downstream,calculate_vm=False)
-                    row = compute_gas_constants(row,fluid)
+                    compute_gas_constants(row,fluid)
                     compute_massflow(row)
                     compute_power(row,upstream)
+                    
+            elif row.loss_function.loss_type == LossType.Enthalpy: 
+                if row.row_type == RowType.Rotor:
+                    row.Yp = 0
+                    rotor_calc(row,upstream,calculate_vm=calculate_vm)
+                    eta_total = float(row.loss_function(row,upstream))
+                    def find_yp(Yp,row,upstream):
+                        row.Yp = Yp
+                        rotor_calc(row,upstream,calculate_vm=True)
+                        row = radeq(row,upstream)
+                        compute_gas_constants(row,fluid)
+                        rotor_calc(row,upstream,calculate_vm=False)
+                        return abs(row.eta_total - eta_total)
+                    
+                    res = minimize_scalar(find_yp,bounds=[0,0.6],args=(row,upstream))
+                    row.Yp = res.x
+                elif row.row_type == RowType.Stator:
+                    row.Yp = 0
+                    stator_calc(row,upstream,downstream,calculate_vm=True)
+                    row = radeq(row,upstream) 
+                    row = compute_gas_constants(row,fluid)
+                    stator_calc(row,upstream,downstream,calculate_vm=False)
+                row = compute_gas_constants(row,fluid)
+                compute_massflow(row)
+                compute_power(row,upstream)
     
 def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:BladeRow,downstream:BladeRow=None,fluid:Solution=None):
     """Finds the blade exit angles that balance the massflow throughout the stage 
@@ -531,14 +533,10 @@ def outlet_pressure(percents:List[float],inletP0:float,outletP:float) -> npt.NDA
     Returns:
         npt.NDArray: Array of static pressures
     """
-    maxP = inletP0
-    minP = outletP
-    if isinstance(percents, float):
-        Ps = [percents*(maxP-minP)+minP]
-    else:
-        Ps = np.zeros(shape=(len(percents),1)); i = 0
-        for p in percents:
-            Ps[i] = p*(maxP - minP) + minP
-            maxP = Ps[i]
-            i+=1
-    return Ps
+    percents = convert_to_ndarray(percents)
+    Ps = np.zeros((len(percents),))
+    for i in range(len(percents)):
+        Ps[i] = float(interp1d((0,1),(inletP0,outletP))(percents[i]))
+        inletP0 = Ps[i] 
+    return Ps
+    

turbo_design-1.3.0/turbodesign/radeq.py

@@ -1,286 +0,0 @@
-from scipy.interpolate import interp1d,PchipInterpolator
-from scipy.integrate import odeint
-import numpy as np  
-import numdifftools as nd 
-from .bladerow import BladeRow
-from .enums import RowType
-
-
-def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
-    """Solves the radial equilibrium equation for axial machines and returns the convergence. 
-
-    Note:
-        This function will give you T0, P0, Vm as a function of the radius. 
-        
-    Args:
-        row (BladeRow): Current row
-        upstream (BladeRow): Previous row
-        downstream (BladeRow): Next row
-        
-    Returns:
-        BladeRow: current row with T0, P0, and Vm calculated
-    """
-    row_radius = row.r     # Use these for gradient 
-    up_radius = upstream.r
-    
-    def ode_radeq_streamtube(r:np.ndarray,y:np.ndarray):
-        """Solves the radial equilibrium equation for a streamtube 
-
-        Args:
-            r (np.ndarray): radius not as a percent
-            y (np.ndarray): Array containing [P0,Vt,VtU,T0]
-            
-        """
-        P0 = y[0]
-        T0 = y[1]
-        Vm = y[2]
-        if r>row_radius[-1]:
-            return [0,0,0]
-        elif r<row_radius[0]:
-            return [0,0,0]
-
-        Cp = row.Cp
-        phi = interp1d(row_radius, row.phi)(r)
-        alpha = interp1d(row_radius, row.alpha2)(r)
-        rm = interp1d(row_radius, row.rm)(r)
-        rho = row.rho.mean()
-        
-        if (row.row_type == RowType.Rotor):
-            omega = row.rpm*np.pi/30
-            U = omega*r
-        else:
-            omega = 0
-            U = 0
-        gamma = row.gamma
-
-        # Solve the Radial Equlibrium 
-        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.tan(alpha)
-        # dVr_dr = dVm_dr*np.sin(phi)
-        
-        up_Vm = interp1d(row_radius, upstream.Vm)(r)
-        if downstream:
-            if downstream.row_type == RowType.Outlet:
-                down_Vm = Vm
-            else:
-                down_Vm = interp1d(row_radius, downstream.Vm)(r)
-        else:
-            down_Vm = Vm
-        up_m = interp1d(row_radius, upstream.m)(r)
-        
-        # Get a rough guess of dVm/dm
-        if downstream!=None:
-            down_m = interp1d(row_radius, downstream.m)(r)
-            row_m = interp1d(row_radius, row.m)(r)
-            if down_m != row_m:
-                func_Vm_m = PchipInterpolator([up_m, row_m, down_m],[up_Vm, Vm, down_Vm])
-            else:
-                func_Vm_m = PchipInterpolator([up_m, row_m],[up_Vm, Vm])    
-        else:
-            func_Vm_m = PchipInterpolator([up_m, row_m],[up_Vm, Vm])    
-        dVm_dm = func_Vm_m.derivative()(row_m)
-        
-        # 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
-        dP0up_dr = float(interp1d(upstream.percent_hub_shroud, np.gradient(upstream.P0,up_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) # use percentage to get the T0 upstream value
-        
-        dP0_dr = float(interp1d(row.percent_hub_shroud, np.gradient(row.P0,row_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) # use percentage to get 
-
-        U_up = float(interp1d(upstream.percent_hub_shroud,up_radius*omega)((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) # use percentage to get the T0 upstream value
-        dVtup_dr = float(interp1d(upstream.percent_hub_shroud,np.gradient(upstream.Vt,up_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0])))
-        Vtup = float(interp1d(upstream.percent_hub_shroud,upstream.Vt)((r-row_radius[0])/(row_radius[-1]-row_radius[0])))
-        
-        
-        dT0_dr = dT0up_dr - 1/row.Cp*(U_up*dVtup_dr + Vtup*omega - (U*dVt_dr+Vt*omega)) # Eqn 8
-        # 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.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))
-        
-        epsilon = 1e-10  # or another small threshold
-        if abs(rm) > epsilon:
-            dVm_dr = Cp*T0/(Vm*A*(1+np.tan(alpha)**2)) * (rho*(Vt**2/r + Vm**2/rm * np.cos(phi) - Vr*dVm_dm) - B*dP0_dr) + Vm/(2*T0) *dT0_dr  # Eqn 6
-        else:
-            dVm_dr = Cp*T0/(Vm*A*(1+np.tan(alpha)**2)) * (rho*(Vt**2/r - Vr*dVm_dm) - B*dP0_dr) + Vm/(2*T0) *dT0_dr  # Eqn 6
-        
-        ydot = np.array([dP0_dr,dT0_dr,dVm_dr])
-
-        return ydot
-
-    T0 = row.T0
-    
-    P0 = row.P0
-    Vm = row.Vm
-
-    # Estimate the Vt based on a given turning angle 
-    mean_radius = row_radius.mean()
-    tip_radius = row_radius[-1]
-    hub_radius = row_radius[0]
-
-    T0m = interp1d(row.percent_hub_shroud,T0)(0.5); 
-    P0m = interp1d(row.percent_hub_shroud,P0)(0.5); Vmm = interp1d(row.percent_hub_shroud,Vm)(0.5)
-    # We are solving for the values of these quantities at row exit
-    ics = np.array([P0m,T0m,Vmm])
-
-    rm_to_tip = np.linspace(mean_radius,tip_radius)
-    res1 = odeint(ode_radeq_streamtube, ics, rm_to_tip, tfirst=True)
-    
-    rm_to_hub = np.flip(np.linspace(hub_radius,mean_radius))
-    res2 = odeint(ode_radeq_streamtube, ics, rm_to_hub, tfirst=True)
-    
-    res2 = np.flipud(res2)
-    res = np.concatenate([res2[:-1,:],res1])
-    r = np.concatenate([np.flip(rm_to_hub)[:-1], rm_to_tip])
-    
-    P0_new = interp1d(r,res[:,0])(row_radius)
-    T0_new = interp1d(r,res[:,1])(row_radius)
-    Vm_new = interp1d(r,res[:,2])(row_radius)
-    
-    row.P0 = P0_new
-    row.T0 = T0_new
-    row.Vm = Vm_new
-    if row.row_type == RowType.Rotor:
-        # U(VT1-VT2) = Power/massflow; VT2 = VT1 - Power/massflow 
-        row.Vt = upstream.Vt-row.power/(row.total_massflow*row.U)
-        row.alpha2 = np.arctan2(row.Vt,row.Vx)
-    elif row.row_type == RowType.Stator:
-        row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)
-    row.Vr = row.Vm*np.sin(row.phi)
-    row.Vx = row.Vm*np.cos(row.phi)
-    
-    return row
-
-
-def radeq_normalized(row:BladeRow,upstream:BladeRow) -> BladeRow:
-    """Solves the radial equilibrium equation for axial or radial machines and returns the convergence. 
-
-    Args:
-        row (BladeRow): Current row
-        upstream (BladeRow): Previous row
-
-    Returns:
-        BladeRow: current row with Vt, T0, P0, and Vm calculated
-    """
-    _,row_radius = row.streamline.get_point(row.percent_hub_shroud)     # Use these for gradient 
-    _,up_radius = upstream.streamline.get_point(upstream.percent_hub_shroud)
-
-    def ode_radeq_streamtube(t:np.ndarray,y:np.ndarray):
-        """Solves the radial equilibrium equation for a streamtube 
-
-        Args:
-            t (np.ndarray): percent from hub to shroud
-            y (np.ndarray): Array containing [P0,Vt,VtU,T0]
-            
-        """
-        P0 = y[0]
-        T0 = y[1]
-        Vm = y[2]
-        if t>1:
-            return [0,0,0]
-        elif t<0:
-            return [0,0,0]
-
-        _,r = row.streamline.get_point()
-        Cp = row.Cp
-        # Interpolate angle of inclination (phi), exit flow angle (alpha), radius of curvature (rm) at a particular percentage from hub to shroud
-        phi = interp1d(row.percent_hub_shroud, row.phi)(t)
-        alpha = interp1d(row.percent_hub_shroud, row.alpha2)(t)
-        rm = interp1d(row.percent_hub_shroud,row.rm)(t)
-        rho = interp1d(row.percent_hub_shroud,row.rho)(t)
-    
-        
-        if (row.row_type == RowType.Rotor):
-            omega = row.rpm*np.pi/30
-            U = omega*r
-        else:
-            omega = 0
-            U = 0
-        gamma = row.gamma
-
-        # Solve the Radial Equlibrium 
-        Vt = Vm*np.cos(phi)*np.tan(alpha)
-        Vr = float(interp1d(row.percent_hub_shroud, row.Vr)(t))
-        # Estimations: need the radius of the streamline to compute gradients  
-        dVm_dr = interp1d(row_radius,np.gradient(row.Vm, row_radius))(r)
-        dVt_dr = dVm_dr*np.cos(phi)*np.tan(alpha)
-        
-        dVm_dm = interp1d(row_radius, np.gradient(Vm, r)) + interp1d(x, np.gradient(Vm, r))
-        
-        # Upstream: We interpolate the gradient based on the percentage from hub to shroud
-        dT0up_dr = interp1d(upstream.percent_hub_shroud,
-                            np.gradient(upstream.T0,up_radius))(t)
-        dP0up_dr = interp1d(upstream.percent_hub_shroud,
-                            np.gradient(upstream.P0,up_radius))(t)
-        dP0_dr = interp1d(upstream.percent_hub_shroud,
-                          np.gradient(upstream.P0,up_radius))(t)
-
-        U_up = interp1d(upstream.percent_hub_shroud,up_radius*omega)(t) # use percentage to get the T0 upstream value
-        dVtup_dr = interp1d(upstream.percent_hub_shroud,np.gradient(upstream.Vt,up_radius))(t)
-        Vtup = interp1d(upstream.percent_hub_shroud,upstream.Vt)(t)
-        
-        dP_dr = interp1d(row.percent_hub_shroud,np.gradient(row.P,row_radius))(t)
-        dT0_dr = dT0up_dr - 1/row.Cp*(U_up*dVtup_dr + Vtup*omega - (U*dVt_dr+Vt*omega)) # Eqn 8
-        # 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)
-        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*dVm_dm) - dP0_dr*B) + 1/(2*T0) *dT0_dr # Eqn 6
-        
-        ydot = np.array([dP0_dr,dT0_dr,dVm_dr])
-
-        return ydot
-
-    T0 = row.T0
-    P0 = row.P0
-    Vm = row.Vm
-
-    # Estimate the Vt based on a given turning angle 
-    _, mean_radius = row.streamline.get_point(0.5)
-    _, tip_radius = row.streamline.get_point(1)
-    _, hub_radius = row.streamline.get_point(0)
-
-    T0m = interp1d(row.percent_hub_shroud,T0)(0.5); 
-    P0m = interp1d(row.percent_hub_shroud,P0)(0.5); 
-    Vmm = interp1d(row.percent_hub_shroud,Vm)(0.5)
-    # We are solving for the values of these quantities at row exit
-    ics = np.array([P0m,T0m,Vmm])
-
-    mid_to_tip = np.linspace(0,1)
-    res1 = odeint(ode_radeq_streamtube, ics, mid_to_tip, tfirst=True) # Results
-    
-    mid_to_hub = np.flip(np.linspace(hub_radius,mean_radius))
-    res2 = odeint(ode_radeq_streamtube, ics, mid_to_hub, tfirst=True) # Results
-    
-    res2 = np.flipud(res2)
-    res = np.concatenate([res2[:-1,:],res1])    # Combine the results
-    t = np.concatenate([np.flip(mid_to_hub)[:-1], mid_to_tip])
-    
-    P0_new = interp1d(t,res[:,0])(row.percent_hub_shroud)
-    T0_new = interp1d(t,res[:,1])(row.percent_hub_shroud)
-    Vm_new = interp1d(t,res[:,2])(row.percent_hub_shroud)
-    
-    row.P0 = P0_new
-    row.T0 = T0_new
-    row.Vm = Vm_new
-    if row.row_type == RowType.Rotor:
-        # U(VT1-VT2) = Power/massflow; VT2 = VT1 - Power/massflow 
-        row.Vt = upstream.Vt-row.power/(row.total_massflow*row.U)
-        row.alpha2 = np.arctan2(row.Vt,row.Vx)
-    elif row.row_type == RowType.Stator:
-        row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)
-    row.Vr = row.Vm*np.sin(row.phi)
-    row.Vx = row.Vm*np.cos(row.phi)
-    
-    return row
-  
-
-