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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: turbo-design
-Version: 1.2.1
+Version: 1.3.0
 Summary: TurboDesign is a library used to design turbines and compressors using radial equilibrium.
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: cantera
 Requires-Dist: findiff
 Requires-Dist: matplotlib

{turbo_design-1.2.1 → turbo_design-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "turbo-design"
-version = "1.2.1"
+version = "1.3.0"
 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.2.1 → turbo_design-1.3.0}/turbodesign/bladerow.py

@@ -34,10 +34,11 @@ class BladeRow:
     # ----------------------------------
 
     # Streamline Properties 
-    axial_location:float = 0 # Where blade row is defined along the hub. 
+    percent_hub:float = 0 # Where blade row is defined along the hub. 
     percent_hub_shroud: npt.NDArray = field(default_factory=lambda: np.array([0]))    # Percent streamline length from hub to shroud.
     x: npt.NDArray = field(default_factory=lambda: np.array([0]))       # x - coordinates (useful for computing axial chord)
     r: npt.NDArray = field(default_factory=lambda: np.array([0]))       # Radius - coordinates 
+    m: npt.NDArray = field(default_factory=lambda: np.array([0]))       # meridional 
     area:float = 0
     # Calculated massflow is the massflow computed after radial eq solver
     calculated_massflow: float = 0
@@ -120,6 +121,7 @@ class BladeRow:
     _tip_clearance:float = 0 # Clearance as a percentage of span or blade height
 
     _inlet_to_outlet_pratio = [0.06,0.95]
+    location:float = 0 # Percent along hub where bladerow is defined
     
     @property
     def inlet_to_outlet_pratio(self) -> Tuple[float,float]:
@@ -327,18 +329,18 @@ class BladeRow:
         """
         self._tip_clearance = val
         
-    def __init__(self,axial_location:float,row_type:RowType=RowType.Stator,stage_id:int = 0):
+    def __init__(self,location:float,row_type:RowType=RowType.Stator,stage_id:int = 0):
         """Initializes the blade row to be a particular type
 
         Args:
-            axial_location (float): Location of the blade row as a percentage of the total axial length
+            location (float): Location of the blade row as a percentage of hub length
             row_type (RowType): Specifies the Type. Defaults to RowType.Stator
             power (float, optional): power . Defaults to 0.
             P0_P (float, optional): Total to Static Pressure Ratio
             stage_id (int, optional): ID of the stage so if you have 9 stages, the id could be 9. It's used to separate the stages. Each stage will have it's own unique degree of reaction 
         """
         self.row_type = row_type
-        self.axial_location = axial_location 
+        self.location = location 
         self.Yp = 0 # Loss
         self.stage_id = stage_id
     
@@ -511,7 +513,7 @@ def interpolate_streamline_radii(row:BladeRow,passage:Passage,num_streamlines:in
     Returns:
         (BladeRow): new row object with quantities interpolated
     """
-    row.cutting_line,_,_ = passage.get_cutting_line(row.axial_location)
+    row.cutting_line,_,_ = passage.get_cutting_line(row.location)
     row.x,row.r = row.cutting_line.get_point(np.linspace(0,1,num_streamlines))
     streamline_percent_length = np.sqrt((row.r-row.r[0])**2+(row.x-row.x[0])**2)/row.cutting_line.length
     
@@ -622,8 +624,8 @@ def compute_gas_constants(row:BladeRow,fluid:Solution=None) -> None:
         Tm = row.T.mean()
         Pm = row.P.mean()
         fluid.TP = Tm,Pm
-        row.Cp = row.fluid.cp
-        row.Cv = row.fluid.cv
+        row.Cp = fluid.cp
+        row.Cv = fluid.cv
         row.R = row.Cp-row.Cv
         row.gamma = row.Cp/row.Cv
     # Use Ideal Gas 

{turbo_design-1.2.1 → turbo_design-1.3.0}/turbodesign/inlet.py

@@ -19,7 +19,7 @@ class Inlet(BladeRow):
     
     def __init__(self,M:float,T0:Union[float,List[float]],
                  P0:Union[float,List[float]],
-                 axial_location:float=0,
+                 location:float=0,
                  beta:Union[float,List[float]]=[0],
                  percent_radii:Union[float,List[float]]=[0.5]):
         """Initializes the inlet station. 
@@ -30,11 +30,11 @@ class Inlet(BladeRow):
             T0 (Union[float,List[float]]): Total Temperature Array
             P0 (Union[float,List[float]]): Total Pressure Array
             percent_radii (Union[float,List[float]]): Radius where total pressure and temperature are defined
-            axial_location (float): Axial Location as a percentage of hub length
+            location (float): Location as a percentage of hub length
             beta (Union[float,List[float]], optional): Inlet flow angle in relative direction. Defaults to [].
 
         """
-        super().__init__(row_type=RowType.Inlet,axial_location=axial_location,stage_id=-1)
+        super().__init__(row_type=RowType.Inlet,location=location,stage_id=-1)
         self.beta1 = convert_to_ndarray(beta)
         self.M = convert_to_ndarray(M)
         self.T0 = convert_to_ndarray(T0)
@@ -94,7 +94,7 @@ class Inlet(BladeRow):
         t,x,radius = passage.get_streamline(self.percent_hub_shroud)
         radius = radius[0]
 
-        cutline,_,_ = passage.get_cutting_line(self.axial_location)
+        cutline,_,_ = passage.get_cutting_line(self.location)
         self.x,self.r = cutline.get_point(np.linspace(0,1,num_streamlines))
         for _ in range(10):
             T0_T = (1+(self.gamma-1)/2 * self.M**2)

{turbo_design-1.2.1 → turbo_design-1.3.0}/turbodesign/outlet.py

@@ -12,7 +12,7 @@ from scipy.interpolate import interp1d
 class Outlet(BladeRow):
     P_fun:interp1d
     
-    def __init__(self,P:Union[float,List[float]],percent_radii:List[float],num_streamlines:int=3):
+    def __init__(self,P:Union[float,List[float]],percent_radii:List[float],num_streamlines:int=3,location:float=1):
         """Initialize the outlet
 
         Args:
@@ -26,6 +26,7 @@ class Outlet(BladeRow):
         self.P_fun = interp1d(self.percent_hub_shroud,self.P)
         self.row_type = RowType.Outlet
         self.loss_function = None
+        self.location = location
     
     
     def transfer_quantities(self,upstream:BladeRow):

{turbo_design-1.2.1 → turbo_design-1.3.0}/turbodesign/passage.py

@@ -1,7 +1,7 @@
 from typing import List, Tuple
 import numpy as np
 import numpy.typing as npt
-from scipy.interpolate import PchipInterpolator
+from scipy.interpolate import PchipInterpolator, interp1d
 from pyturbo.helper import line2D
 from .enums import PassageType
 from scipy.optimize import minimize_scalar
@@ -141,7 +141,7 @@ class Passage:
         r = r_streamline
             
         return phi, rm, r
-    
+        
     def get_area(self,t_hub:float) -> float:
         """Get Area
 
@@ -166,7 +166,7 @@ class Passage:
                 total_area += area
         return total_area
         
-    def get_cutting_line(self, t_hub:float) -> line2D:
+    def get_cutting_line(self, t_hub:float) -> Tuple[line2D,float,float]:
         """Gets the cutting line perpendicular to hub and shroud 
 
         Args:
@@ -212,17 +212,18 @@ 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:Tuple[float,float]):
+    def get_xr_slice(self,t_span:float,percent_hub:Tuple[float,float],resolution:int=100):
         """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_
+            meridional_location (float): _description_
+            resolution (int): number of points to resolve 
 
         Returns:
             np.NDArray: _description_
         """
-        t_hub = np.linspace(axial_location[0],axial_location[1],100)
+        t_hub = np.linspace(percent_hub[0],percent_hub[1],resolution)
         t_hub = convert_to_ndarray(t_hub)*self.hub_length
         
         shroud_pts_cyl = np.vstack([self.xshroud(t_hub),self.rshroud(t_hub)]).transpose()
@@ -233,8 +234,39 @@ class Passage:
         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
-        
+    
+    def get_m(self,t_span:float,resolution:int=100) -> npt.NDArray:
+        """Meridional cooridnates
+
+        Args:
+            t_span (float): _description_
+            resolution (int, optional): _description_. Defaults to 100.
+
+        Returns:
+            npt.NDArray: _description_
+        """
+        xr = self.get_xr_slice(t_span,(0,1),resolution)
+        dx = np.diff(xr[:,0])
+        dr = np.diff(xr[:,1])
+        m = np.concat([[0],np.cumsum(np.sqrt(dx**2 + dr**2))])
+        return m
+    
+    def get_dm(self,t_span:float,location:float,resolution:int=1000) -> float:
+        """return the derivative in the meridional direction at a particular point
+
+        Args:
+            t_span (float): percent span 
+            location (float): hub location of the blade
+            resolution (int, optional): number of points to represent the hub curve. Defaults to 1000.
+
+        Returns:
+            (float) : returns the derivative 
+        """
+        m = self.get_m(t_span,resolution)
+        return PchipInterpolator(np.linspace(0,1,resolution),np.diff(m))(location)
+    
     @property
     def hub_length(self):
         """returns the computed length of the hub 

{turbo_design-1.2.1 → turbo_design-1.3.0}/turbodesign/radeq.py

@@ -1,11 +1,12 @@
-from scipy.interpolate import interp1d
+from scipy.interpolate import interp1d,PchipInterpolator
 from scipy.integrate import odeint
-import numpy as np 
+import numpy as np  
+import numdifftools as nd 
 from .bladerow import BladeRow
 from .enums import RowType
 
 
-def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
+def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
     """Solves the radial equilibrium equation for axial machines and returns the convergence. 
 
     Note:
@@ -14,7 +15,8 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
     Args:
         row (BladeRow): Current row
         upstream (BladeRow): Previous row
-
+        downstream (BladeRow): Next row
+        
     Returns:
         BladeRow: current row with T0, P0, and Vm calculated
     """
@@ -57,8 +59,30 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
         # 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)
-
+        # 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
@@ -82,9 +106,9 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
         
         epsilon = 1e-10  # or another small threshold
         if abs(rm) > epsilon:
-            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
+            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 = 1/(2*Vm*A) * (rho*(Vt/r - Vr*dVr_dr) - dP0_dr*B) + 1/(2*T0) *dT0_dr  # Eqn 6
+            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])
 

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

@@ -27,13 +27,13 @@ def adjust_streamlines(blade_rows:List[BladeRow],passage:Passage):
         new_percent_streamline = interp1d(row.massflow,row.percent_hub_shroud)(ideal_massflow_fraction[1:-1])
         row.percent_hub_shroud[1:-1] = new_percent_streamline
 
-        cut_line, thub,_ = passage.get_cutting_line(row.axial_location)
+        cut_line, thub,_ = passage.get_cutting_line(row.percent_hub)
         row.x,row.r = cut_line.get_point(row.percent_hub_shroud)
         # Radii may have shifted, recompute Ay and rm
         for i,tr in enumerate(row.percent_hub_shroud):
             t_streamline, x_streamline, r_streamline = passage.get_streamline(tr)                
             phi, rm, r = passage.streamline_curvature(x_streamline,r_streamline)
-            row.phi[i] = float(interp1d(t_streamline,phi)(row.axial_location))
-            row.rm[i] = float(interp1d(t_streamline,rm)(row.axial_location))
-            row.r[i] = float(interp1d(t_streamline,r)(row.axial_location))
-            row.x[i] = float(interp1d(t_streamline,x_streamline)(row.axial_location))
+            row.phi[i] = float(interp1d(t_streamline,phi)(row.percent_hub))
+            row.rm[i] = float(interp1d(t_streamline,rm)(row.percent_hub))
+            row.r[i] = float(interp1d(t_streamline,r)(row.percent_hub))
+            row.x[i] = float(interp1d(t_streamline,x_streamline)(row.percent_hub))

{turbo_design-1.2.1 → turbo_design-1.3.0}/turbodesign/spool.py

@@ -34,7 +34,7 @@ class Spool:
     def __init__(self,passage:Passage,
                  massflow:float,rows=List[BladeRow],
                  num_streamlines:int=3,
-                 fluid:Solution=Solution('air.yaml'),
+                 fluid:Solution=None,
                  rpm:float=-1,
                  massflow_constraint:MassflowConstraint=MassflowConstraint.MatchMassFlow):
         """Initializes a Spool
@@ -50,7 +50,7 @@ class Spool:
             massflow (float): massflow at spool inlet 
             rows (List[BladeRow], optional): List of blade rows. Defaults to List[BladeRow].
             num_streamlines (int, optional): number of streamlines. Defaults to 3.
-            gas (ct.Solution, optional): cantera gas solution. Defaults to ct.Solution('air.yaml').
+            fluid (ct.Solution, optional): cantera gas solution. Defaults to None, fluid is set by bladerow cp
             rpm (float, optional): RPM for the entire spool Optional, you can also set rpm of the blade rows individually. Defaults to -1.
             massflow_constraint (MassflowConstraint, optional): MatchMassflow - Matches the massflow defined in the spool. BalanceMassflow - Balances the massflow between BladeRows, matches the lowest massflow.
         """
@@ -71,7 +71,7 @@ class Spool:
             '''    
             if (type(self.blade_rows[i]) != Inlet) and (type(self.blade_rows[i]) != Outlet):
                 self.blade_rows[i].rpm = rpm
-                self.blade_rows[i].axial_chord = self.blade_rows[i].axial_location * self.passage.hub_length
+                self.blade_rows[i].axial_chord = self.blade_rows[i].location * self.passage.hub_length
             
 
     @property
@@ -158,10 +158,11 @@ class Spool:
             row.phi = np.zeros((self.num_streamlines,))
             row.rm = np.zeros((self.num_streamlines,))
             row.r = np.zeros((self.num_streamlines,))
+            row.m = np.zeros((self.num_streamlines,))
             
             t_radial = np.linspace(0,1,self.num_streamlines)
             self.calculate_streamline_curvature(row,t_radial)
-                
+            
             # Set the loss function if it's not set
             if (type(row)!= Inlet and type(row) != Outlet):  
                 if row.loss_function == None:
@@ -177,9 +178,10 @@ class Spool:
         for i,tr in enumerate(t_radial):
             t_streamline, x_streamline, r_streamline = self.passage.get_streamline(tr)                
             phi, rm, r = self.passage.streamline_curvature(x_streamline,r_streamline)
-            row.phi[i] = float(interp1d(t_streamline,phi)(row.axial_location))
-            row.rm[i] = float(interp1d(t_streamline,rm)(row.axial_location))
-            row.r[i] = float(interp1d(t_streamline,r)(row.axial_location))
+            row.phi[i] = float(interp1d(t_streamline,phi)(row.location))
+            row.rm[i] = float(interp1d(t_streamline,rm)(row.location))
+            row.r[i] = float(interp1d(t_streamline,r)(row.location))
+            row.m[i] = float(interp1d(t_streamline,self.passage.get_m(tr,resolution=len(t_streamline)))(row.location))
           
     def solve(self):
         raise NotImplementedError('Solve is not implemented')
@@ -214,10 +216,10 @@ class Spool:
             else:  # i>0
                 upstream = self.blade_rows[i-1]
                 if upstream.row_type== RowType.Inlet:
-                    cut_line1,_,_ = self.passage.get_cutting_line((row.axial_location*hub_length +(0.5*row.blade_to_blade_gap*row.axial_chord) - row.axial_chord)/hub_length)
+                    cut_line1,_,_ = self.passage.get_cutting_line((row.location*hub_length +(0.5*row.blade_to_blade_gap*row.axial_chord) - row.axial_chord)/hub_length)
                 else:
-                    cut_line1,_,_ = self.passage.get_cutting_line((upstream.axial_location*hub_length)/hub_length)
-                cut_line2,_,_ = self.passage.get_cutting_line((row.axial_location*hub_length-(0.5*row.blade_to_blade_gap*row.axial_chord))/hub_length)
+                    cut_line1,_,_ = self.passage.get_cutting_line((upstream.location*hub_length)/hub_length)
+                cut_line2,_,_ = self.passage.get_cutting_line((row.location*hub_length-(0.5*row.blade_to_blade_gap*row.axial_chord))/hub_length)
                 
             if self.blade_rows[i].row_type == RowType.Stator:
                 x1,r1 = cut_line1.get_point(np.linspace(0,1,10))

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

@@ -93,7 +93,7 @@ def compute_reynolds(rows:List[BladeRow],passage:Passage):
     
     for i in range(1,len(rows)):
         row = rows[i]
-        xr = passage.get_xr_slice(0.5,[rows[i-1].axial_location,row.axial_location])
+        xr = passage.get_xr_slice(0.5,[rows[i-1].location,row.percent_hub])
         dx = np.diff(xr[:,0])
         dr = np.diff(xr[:,1])
         c = np.sum(np.sqrt(dx**2+dr**2))
@@ -111,8 +111,6 @@ def compute_reynolds(rows:List[BladeRow],passage:Passage):
         row.axial_chord = max(c,1E-12) # Axial chord
         # row.num_blades = int(2*np.pi*row.r.mean() / row.pitch_to_chord * row.axial_chord)
 
-
-    
 def compute_power(row:BladeRow,upstream:BladeRow) -> None:
     """Calculates the power
 
@@ -232,8 +230,9 @@ def stator_calc(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None,calculat
     
     # Static Pressure is assumed 
     row.P0 = upstream.P0 - row.Yp*(upstream.P0-row.P)
-    row.P0_P = row.P0/downstream.P
+    
     if downstream is not None:
+        row.P0_P = row.P0/downstream.P
         row.rp = (row.P-downstream.P)/(upstream.P0-downstream.P)
         
     if calculate_vm:
@@ -261,6 +260,7 @@ def stator_calc(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None,calculat
     row.beta1 = upstream.beta2
     row.rho = row.P/(row.R*row.T)
     row.U = row.omega*row.r
+    row.Wt = row.Vt-row.U
     row.P0_stator_inlet = upstream.P0
 
 def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
@@ -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.T0R - T0_coolant_weighted_average(row) # (upstream_rothalpy + 0.5*row.U**2)/row.Cp - T0_coolant_weighted_average(row) 
+    row.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

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

@@ -53,15 +53,15 @@ class TurbineSpool(Spool):
                                     gamma=self.blade_rows[1].gamma,
                                     Cp=self.blade_rows[1].Cp)
         
-            inlet.total_massflow = W0 
-            inlet.total_massflow_no_coolant = W0
-            inlet.massflow = np.linspace(0,1,self.num_streamlines)*W0
-            
-            inlet.initialize_velocity(self.passage,self.num_streamlines)    
-            interpolate_streamline_radii(inlet,self.passage,self.num_streamlines)
+        inlet.total_massflow = W0 
+        inlet.total_massflow_no_coolant = W0
+        inlet.massflow = np.linspace(0,1,self.num_streamlines)*W0
+        
+        inlet.initialize_velocity(self.passage,self.num_streamlines)    
+        interpolate_streamline_radii(inlet,self.passage,self.num_streamlines)
 
-            compute_gas_constants(inlet,self.fluid)
-            inlet_calc(inlet)
+        compute_gas_constants(inlet,self.fluid)
+        inlet_calc(inlet)
         
         for row in self.blade_rows:
             interpolate_streamline_radii(row,self.passage,self.num_streamlines)
@@ -122,10 +122,12 @@ class TurbineSpool(Spool):
             
             if row.row_type == RowType.Stator:
                 stator_calc(row,upstream,downstream)
+                compute_massflow(row)
             elif row.row_type == RowType.Rotor:
                 rotor_calc(row,upstream)
                 compute_massflow(row)
                 compute_power(row,upstream)        
+            
     
     def solve(self):
         """
@@ -163,7 +165,7 @@ class TurbineSpool(Spool):
                     bounds = [-80,0]
                 if row.row_type != RowType.Inlet:
                     for j in range(1,self.num_streamlines):
-                        res = minimize_scalar(massflow_loss_function, bounds=bounds,args=(j,row,upstream,downstream),tol=1E-2)
+                        res = minimize_scalar(massflow_loss_function, bounds=bounds,args=(j,row,upstream,downstream),tol=1E-3)
                         if row.row_type == RowType.Rotor:
                             row.beta2[j] = np.radians(res.x)
                              # Initialize the value at the hub to not upset the mean
@@ -178,7 +180,34 @@ class TurbineSpool(Spool):
             # Step 3: Adjust streamlines to evenly divide massflow
             adjust_streamlines(self.blade_rows,self.passage)
         compute_reynolds(self.blade_rows,self.passage)
-            
+    
+    @staticmethod # Private static method
+    def __massflow_std__(blade_rows:List[BladeRow]):
+        """Returns the standard deviation of the massflow
+
+        Args:
+            blade_rows (List[BladeRow]): List of blade rows
+
+        Returns:
+            _type_: _description_
+        """
+        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
+            total_massflow.append(row.total_massflow_no_coolant)
+            sign = 1
+            for s in stage_ids:
+                for row in blade_rows:
+                    if row.stage_id == s and row.row_type == RowType.Rotor:
+                        massflow_stage.append(sign*row.total_massflow_no_coolant)
+                        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  
+    
     def __balance_massflow(self):
         """ Balances the massflow between rows. Use radial equilibrium.
 
@@ -195,24 +224,7 @@ class TurbineSpool(Spool):
                 3. Adjust the streamlines for each blade row to balance the massflow
         """
         
-        def calculate_error(blade_rows):
-            total_massflow = list(); s = 0; massflow_stage = list()
-            stage_ids = list(set([row.stage_id for row in self.blade_rows if row.stage_id>=0]))
-            for row in blade_rows[1:]:
-                total_massflow.append(row.total_massflow_no_coolant)
-                
-                sign = 1
-                for s in stage_ids:
-                    for row in blade_rows:
-                        if row.stage_id == s and row.row_type == RowType.Rotor:
-                            massflow_stage.append(sign*row.total_massflow_no_coolant)
-                            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
         def balance_massflows(x0:List[float],blade_rows:List[List[BladeRow]],P0:npt.NDArray,P:npt.NDArray,balance_mean_pressure:bool=True):
@@ -239,27 +251,24 @@ class TurbineSpool(Spool):
             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 i in range(1,len(blade_rows)-2):
                         blade_rows[i].P[j] = Ps_range[i-1]
-                blade_rows[-1].P = P
+                blade_rows[-2].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]*x0[(i-1)*self.num_streamlines+j]    # x0 size = num_streamlines -1 
-            try:  
-                calculate_massflows(blade_rows,True)
-                print(x0)
-                return calculate_error(blade_rows)
-            except:
-                blade_rows = blade_rows_backup
-                return np.inf # Return a high error
+            # try:  
+            calculate_massflows(blade_rows,True,self.fluid)
+            print(x0)
+            return self.__massflow_std__(blade_rows)
+            # except Exception as e:
+            #     print(e)
+            # finally:
+            #     blade_rows = blade_rows_backup
+            #     return np.inf # Return a high error
             
-            # 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 
         
@@ -267,63 +276,38 @@ class TurbineSpool(Spool):
             outlet_P.append(self.blade_rows[i].inlet_to_outlet_pratio)
             outlet_P_guess.append(np.mean(self.blade_rows[i].inlet_to_outlet_pratio))
         
-        print('Find average P in between stages')
-        if len(outlet_P) == 1:
-            # x = balance_massflows(0.658,self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P)
-            res = minimize_scalar(fun=balance_massflows,args=(self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P),bounds=outlet_P[0],tol=0.0001,options={'disp': True},method='bounded')
-            x = res.x
-            print(x)
-        else:
-            x = fmin_slsqp(func=balance_massflows,args=(self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P), 
-                        bounds=outlet_P, x0=outlet_P_guess,epsilon=0.001,iter=100) # ,tol=0.001,options={'disp': True})
-            outlet_P_guess = x 
+        print(f"Looping to converge massflow")
+        past_err = -100; loop_iter = 0; err = 0.001
+        while np.abs((err-past_err)/err)>0.05:
+            if len(outlet_P) == 1:
+                # x = balance_massflows(0.658,self.blade_rows[:-1],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)
+            else:
+                x = fmin_slsqp(func=balance_massflows,args=(self.blade_rows,self.blade_rows[0].P0,self.blade_rows[-1].P), 
+                            bounds=outlet_P, x0=outlet_P_guess,epsilon=0.001,iter=100) # ,tol=0.001,options={'disp': True})
+                outlet_P_guess = x 
         
-        # Adjust the inlet: Set the massflow
-        self.blade_rows[0].massflow = np.linspace(0,1,self.num_streamlines)*self.blade_rows[1].total_massflow_no_coolant
-        self.blade_rows[0].total_massflow_no_coolant = self.blade_rows[1].total_massflow_no_coolant
-        self.blade_rows[0].total_massflow = np.linspace(0,1,self.num_streamlines)*self.blade_rows[1].total_massflow_no_coolant
-        inlet_calc(self.blade_rows[0]) # adjust the inlet to match massflow 
+            # Adjust the inlet: Set the massflow
+            self.blade_rows[0].massflow = np.linspace(0,1,self.num_streamlines)*self.blade_rows[1].total_massflow_no_coolant
+            self.blade_rows[0].total_massflow_no_coolant = self.blade_rows[1].total_massflow_no_coolant
+            self.blade_rows[0].total_massflow = np.linspace(0,1,self.num_streamlines)*self.blade_rows[1].total_massflow_no_coolant
+            self.blade_rows[0].calculated_massflow = self.blade_rows[0].total_massflow_no_coolant
+            inlet_calc(self.blade_rows[0]) # adjust the inlet to match massflow 
         
-        if self.adjust_streamlines:
-            for _ in range(2):
+            if self.adjust_streamlines:
                 adjust_streamlines(self.blade_rows[:-1],self.passage)
-                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)
-                balance_massflows(x,self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P) 
-        else:
+                
             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)
-        err = calculate_error(self.blade_rows[:-1])
-        print(f"Massflow convergenced error:{err}")
+            
+            err = self.__massflow_std__(self.blade_rows)
+            print(f"Loop {loop_iter} massflow convergenced error:{err}")
         
         # calculate Reynolds number
         compute_reynolds(self.blade_rows,self.passage)
         
-        # finetune = True
-        # if finetune:        
-        #     print('Finetune static pressure between stages')
-        #     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)
-        #     P = [row.P for row in self.blade_rows] # Average static pressures
-        #     bounds = []; guess = []
-        #     for i in range(1,len(self.blade_rows)-1): # set the bounds 
-        #         for j in range(self.num_streamlines):
-        #             bounds.append([0.8,1.2]) # vary by +- 20%
-        #             guess.append(1)
-            
-        #     x = fmin_slsqp(func=balance_massflows,args=(self.blade_rows[:-1],self.blade_rows[0].P0,P,False), 
-        #                 bounds=bounds, x0=guess,epsilon=0.001,iter=200)
-        #     P = [row.P for row in self.blade_rows] # Average static pressures
-            
-        #     for _ in range(2):
-        #         adjust_streamlines(self.blade_rows[:-1],self.passage)
-        #         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)
-        #         balance_massflows(x,self.blade_rows[:-1],self.blade_rows[0].P0,P,False)
-                
-        #     err = calculate_error(self.blade_rows[:-1])
-        #     print(f"Massflow convergenced error after finetuning:{err}")
-            
     
     def export_properties(self,filename:str="turbine_spool.json"):
         """Export the spool object to json 
@@ -337,7 +321,7 @@ class TurbineSpool(Spool):
         total_static_efficiency = list()
         stage_loading = list() 
         euler_power = list() 
-        
+        enthalpy_power = list()
         x_streamline = np.zeros((self.num_streamlines,len(self.blade_rows)))
         r_streamline = np.zeros((self.num_streamlines,len(self.blade_rows)))
         massflow = list()
@@ -352,14 +336,14 @@ class TurbineSpool(Spool):
 
                 stage_loading.append(row.stage_loading)
                 euler_power.append(row.euler_power)
-            
+                enthalpy_power.append(row.power)
             if row.row_type!=RowType.Inlet and row.row_type!=RowType.Outlet:
                 massflow.append(row.massflow[-1])
             
             for j,p in enumerate(row.percent_hub_shroud):
                 t,x,r = self.passage.get_streamline(p)
-                x_streamline[j,indx] = float(interp1d(t,x)(row.axial_location))
-                r_streamline[j,indx] = float(interp1d(t,r)(row.axial_location))
+                x_streamline[j,indx] = float(interp1d(t,x)(row.percent_hub))
+                r_streamline[j,indx] = float(interp1d(t,r)(row.percent_hub))
         
         Pratio_Total_Total = np.mean(self.blade_rows[0].P0 / self.blade_rows[-2].P0)
         Pratio_Total_Static = np.mean(self.blade_rows[0].P0 / self.blade_rows[-2].P)
@@ -378,6 +362,8 @@ class TurbineSpool(Spool):
             "xhub":self.passage.xhub_pts.tolist(),
             "xshroud":self.passage.xshroud_pts.tolist(),
             "num_streamlines":self.num_streamlines,
+            "euler_power": euler_power,
+            "enthalpy_power":enthalpy_power,
             "total-total_efficiency":total_total_efficiency,
             "total-static_efficiency":total_static_efficiency,
             "stage_loading":stage_loading,
@@ -408,7 +394,7 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False,fluid:
         calculate_vm (bool, optional): _description_. Defaults to False.
     """
     for p in range(3):
-        for i in range(1,len(blade_rows)):
+        for i in range(1,len(blade_rows)-1):
             row = blade_rows[i]
             # Upstream Row
             if i == 0:
@@ -417,8 +403,6 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False,fluid:
                 upstream = blade_rows[i-1]
             if i<len(blade_rows)-1:
                 downstream = blade_rows[i+1]
-            else:
-                downstream = None 
             
             # Pressure loss = shift in entropy which affects the total pressure of the row
             if row.row_type == RowType.Inlet:
@@ -430,13 +414,13 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False,fluid:
                         if row.row_type == RowType.Rotor:
                             rotor_calc(row,upstream,calculate_vm=True)
                             # Finds Equilibrium between Vm, P0, T0
-                            row = radeq(row,upstream) 
+                            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)
+                            row = radeq(row,upstream,downstream)
                             compute_gas_constants(row,fluid)
                             stator_calc(row,upstream,downstream,calculate_vm=False)
                         compute_gas_constants(row,fluid)