turbo-design 1.1.4__py3-none-any.whl → 1.3.0__py3-none-any.whl

{turbo_design-1.1.4.dist-info → turbo_design-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: turbo-design
-Version: 1.1.4
+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.1.4.dist-info → turbo_design-1.3.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 turbodesign/__init__.py,sha256=N8Nu0I1vrlEHYJZZ7yhhg-FtbNbLyrgjy7hoicygUqg,325
 turbodesign/arrayfuncs.py,sha256=GHIlTyLfeNsNCQQoh5m1aXK3iyvU6RjdYQipkqpU_ps,519
-turbodesign/bladerow.py,sha256=WqAB_BZFXu-y-m-leSbDNxUlt578A4clJhaNkkpxBbM,24731
+turbodesign/bladerow.py,sha256=v4tX27aOL7iuN0ILWYbtSbANWZ_7_LIxksu4ux1aQ2o,24959
 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
+turbodesign/coolant.py,sha256=evDtUFOYhfZKTVAsDWzxRzUX20gTvfjj0uybaWg4CsI,427
 turbodesign/enums.py,sha256=T4aFrGMnx9fgZkrExMBIY2IbCueA0utqr_afk-TUe9Q,1188
-turbodesign/inlet.py,sha256=QeSvFi35JeOPevjQrz1TmAhoWkScXT9BRA_5oRTnDEE,6322
+turbodesign/inlet.py,sha256=L_IHE8zzm3uFMSow0iO-VxI71SnyQZwRhJMlJDcwZ4o,7329
 turbodesign/isentropic.py,sha256=YLTmNx69e_M5fTuLOmk_KvaQ6ABv0aZsityfBihJOmI,2003
 turbodesign/loss/__init__.py,sha256=ZJomzXa6ElduFruURukCrFwJQXMWS2aW8JSaVQ-M2r8,46
 turbodesign/loss/compressor/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
@@ -19,15 +19,15 @@ turbodesign/loss/turbine/fixedpressureloss.py,sha256=jbm8dt8wtyN1RaOgpgYZsvwM0-0
 turbodesign/loss/turbine/kackerokapuu.py,sha256=hUmZdyA1hAhN3_xbwBhka2dyk0Aq9rqq62S2ghuKSOk,5071
 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=vKcEzQmQIlc-88DD1zr2f0F5s1r4x6OFQLtuTgkYMBA,10033
-turbodesign/radeq.py,sha256=RCsiQzcHvR5dozK6XG0eysAhXYewF0BY_qX0f1knURo,10091
+turbodesign/outlet.py,sha256=-0XpeEmTQpFjUQNYQxOp5WuHkF7cXfx59hxy7BmaxgY,2119
+turbodesign/passage.py,sha256=Ur6zZCzI9Y7HW0o5LrDq9yeatRain1mBLZBcTOzgjEU,11996
+turbodesign/radeq.py,sha256=3XuSf_KtOqddJclcxh9v1V2YWMvbWfd0YxcHGkic7hg,11361
 turbodesign/rotor.py,sha256=tHl9o5H4aQ6Etd4gqa8Ime1UK7k0de4GLt5Yb1sJdGs,1376
-turbodesign/solve_radeq.py,sha256=2VGzFSVkyN0rTPFHaCQiD3v166cdEs39x7x7RuzLgmw,1886
-turbodesign/spool.py,sha256=h4m--HR5g8o01Kkhl4Mbvx7WORQez3YpncDE7XxbNaw,14172
+turbodesign/solve_radeq.py,sha256=mGVBHmc20pAXEDKGzyiU3BVUsmY9gJl7zhbtHZqxARg,1956
+turbodesign/spool.py,sha256=XKvYABvfigLulGLHH23X7k6aL6wvfuqgfLkKCMK9X8c,14338
 turbodesign/stage.py,sha256=UP45sDKDLsAkO_WfDWJ6kqXU7cYKh_4QO01QZnSN1oQ,166
-turbodesign/td_math.py,sha256=GjJdH9Mym1_vMSDT7lxilzSLVHBM5-Z5UE0wfsH2hr4,16153
-turbodesign/turbinespool.py,sha256=U_TMv5XNTlRWP9NJWTaaFWfNeTEGEuSVWt3HDi8QyFI,26124
-turbo_design-1.1.4.dist-info/METADATA,sha256=4pe7fwIxSnpYVF86iou7pFaKh4usQfKMe2Co--6U__w,683
-turbo_design-1.1.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-turbo_design-1.1.4.dist-info/RECORD,,
+turbodesign/td_math.py,sha256=NMKgHkc36LCrr4bZxjxx7TcA4ztaRps1cIsm1tucMrk,16069
+turbodesign/turbinespool.py,sha256=I5e1l8SsvwsQZZkOv7ric83-uNvT9MExwCimJEAhaI8,25194
+turbo_design-1.3.0.dist-info/METADATA,sha256=qSAB19ivwujv2mpnh8XwkwdSuVNIbiYNMYozn6ccPW0,734
+turbo_design-1.3.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+turbo_design-1.3.0.dist-info/RECORD,,

{turbo_design-1.1.4.dist-info → turbo_design-1.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.0.1
 Root-Is-Purelib: true
 Tag: py3-none-any

turbodesign/bladerow.py

@@ -26,7 +26,6 @@ class BladeRow:
     Cp: float = 1019            # Cp J/(Kg*K)
     Cv: float = 1019/1.14       # Cv J/(Kg*K)
     _coolant:Coolant = None     # type: ignore # Coolant Fluid
-    fluid: composite.Solution = Solution("air.yaml")
     mu:float = 0 
     
     total_massflow:float = 0    # Massflow spool + all upstream cooling flow [kg/s]
@@ -35,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
@@ -121,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]:
@@ -328,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
     
@@ -437,7 +438,7 @@ class BladeRow:
         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"
+        return f"{self.row_type.name} P0:{np.mean(self.P0):0.2f} T0:{np.mean(self.T0):0.2f} P:{np.mean(self.P):0.2f} massflow:{np.mean(self.total_massflow_no_coolant):0.3f}"
     
     def to_dict(self):
         
@@ -512,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
     
@@ -609,21 +610,24 @@ def interpolate_quantities(q:npt.NDArray,r:npt.NDArray,r2:npt.NDArray):
     else:
         return interp1d(r,q,kind='linear')(r2)
     
-def compute_gas_constants(row:BladeRow):
-    """Calculates all the gas constants for a row. 
-        This should be done if T or P change 
+def compute_gas_constants(row:BladeRow,fluid:Solution=None) -> None:
+    """Updates the Cp, Gamma, and density for a blade row. If fluid is not specified then only density and viscosity is updated. 
+    
+    Args:
+        row (BladeRow): _description_
+        fluid (Solution, optional): _description_. Defaults to None.
+
+    Returns:
+        (BladeRow): updated row
     """
-    Tm = row.T.mean()
-    Pm = row.P.mean()
-    row.fluid.TP = Tm,Pm
-    row.Cp = row.fluid.cp
-    row.Cv = row.fluid.cv
-    row.R = row.Cp-row.Cv
-    row.gamma = row.Cp/row.Cv
-    row.mu = sutherland(Tm) # type: ignore
-    row.rho[:] = row.fluid.density
-    # i = 0 
-    # for T,P in zip(row.T,row.P):
-    #     row.rho[i] = P/(T*row.R)
-    #     i+=1
-    return row
+    if fluid:
+        Tm = row.T.mean()
+        Pm = row.P.mean()
+        fluid.TP = Tm,Pm
+        row.Cp = fluid.cp
+        row.Cv = fluid.cv
+        row.R = row.Cp-row.Cv
+        row.gamma = row.Cp/row.Cv
+    # Use Ideal Gas 
+    row.rho = row.P/(row.T*row.R)
+    row.mu = sutherland(row.T) # type: ignore

turbodesign/coolant.py

@@ -3,8 +3,8 @@ from cantera import Solution
 
 @dataclass
 class Coolant:
-    fluid:Solution = field(default = Solution('air.yaml')) # cantera solution
     T0:float = field(default=900)                               # Kelvin
     P0:float = field(default=50*101325)                         # Pascal
-    massflow_percentage:float = field(default=0.03)     # Fraction of total massflow going through compressor 
+    massflow_percentage:float = field(default=0.03)     # Fraction of total massflow going through compressor
+    Cp:float = field(default=1000)                              # J/K
     

turbodesign/inlet.py

@@ -16,57 +16,85 @@ class Inlet(BladeRow):
         (BladeRow): Defines the properties of the blade row
     """
     fun: interp1d
-    def __init__(self,M:float,T0:Union[float,List[float]],P0:Union[float,List[float]],percent_radii:Union[float,List[float]],fluid:Solution,axial_location:float=0,beta:Union[float,List[float]]=[0]):
+    
+    def __init__(self,M:float,T0:Union[float,List[float]],
+                 P0:Union[float,List[float]],
+                 location:float=0,
+                 beta:Union[float,List[float]]=[0],
+                 percent_radii:Union[float,List[float]]=[0.5]):
         """Initializes the inlet station. 
             Uses the beta and exit mach number to predict a value for Vm
 
         Args:
             M (float): Mach number at the inlet plane
-            beta (Union[float,List[float]]): exit relative flow angle
             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
-            fluid (ct.Solution): Cantera mixture
-            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)
-        self.loss_function = None
+        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)
         self.P0 = convert_to_ndarray(P0)
         self.percent_hub_shroud = convert_to_ndarray(percent_radii)
+        
+    
+    def initialize_fluid(self,fluid:Solution=None,R:float=287.15,gamma:float=1.4,Cp:float=1024):
+        """Initialize the inlet using the fluid. This function should be called by a class that inherits from spool
+
+        Args:
+            fluid (Solution, optional): Cantera fluid object. Defaults to None.
+            R (float, optional): Ideal Gas Constant. Defaults to 287.15 J/(Kg K) for air
+            gamma (float, optional): _description_. Defaults to 1.4.
+            Cp (float, optional): _description_. Defaults to 1024 J/(Kg K).
+        
+        """
+        self.loss_function = None
+        
         # if it's inlet alpha and beta are the same, relative flow angle = absolute. 
-        self.beta2 = np.radians(convert_to_ndarray(beta))
-        self.alpha1 = np.radians(convert_to_ndarray(beta))
-        fluid.TP = self.T0.mean(),self.P0.mean()
-        self.gamma = fluid.cp/fluid.cv
+        self.beta2 = np.radians(convert_to_ndarray(self.beta1))
+        self.alpha1 = np.radians(convert_to_ndarray(self.beta1))
         
-        self.T = self.T0 * 1/(1 + (self.gamma-1) * self.M**2)
-        self.P = self.P0 * 1/(1 + (self.gamma-1) * self.M**2)**(self.gamma/(self.gamma-1))
-        fluid.TP = self.T.mean(),self.P.mean()
-        self.rho = convert_to_ndarray([fluid.density])
-        self.fluid = fluid
+        if fluid:
+            fluid.TP = self.T0.mean(),self.P0.mean()
+            self.gamma = fluid.cp/fluid.cv
+            self.T = self.T0 * 1/(1 + (self.gamma-1) * self.M**2)
+            self.P = self.P0 * 1/(1 + (self.gamma-1) * self.M**2)**(self.gamma/(self.gamma-1))
+            fluid.TP = self.T.mean(),self.P.mean()
+            self.rho = convert_to_ndarray([fluid.density])
+        else:
+            self.Cp = Cp
+            self.gamma = gamma
+            self.R = R
+            self.T = self.T0 * 1/(1 + (self.gamma-1) * self.M**2)
+            self.P = self.P0 * 1/(1 + (self.gamma-1) * self.M**2)**(self.gamma/(self.gamma-1))
+            self.rho = self.P/(self.R*self.T)
+
         self.rpm = 0
-        
         self.beta1_metal = [0] 
         self.beta2_metal = [0]
-        self.P0_fun = interp1d(self.percent_hub_shroud,P0)
-        self.T0_fun = interp1d(self.percent_hub_shroud,T0)
+        self.P0_fun = interp1d(self.percent_hub_shroud,self.P0)
+        self.T0_fun = interp1d(self.percent_hub_shroud,self.T0)
         self.mprime = [0]
-
         
     def initialize_velocity(self,passage:Passage,num_streamlines:int):
         """Initialize velocity calculations. Assumes streamlines and inclination angles have been calculated 
-     
+            Call this before performing calculations
+            
+        Args:
+            passage (Passage): Passage object
+            num_streamlines (int): number of streamlines
+        
         """
         # Perform Calculations on Velocity 
         Vm_prev = 0; Vm_err = 0 
         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)
@@ -84,7 +112,7 @@ class Inlet(BladeRow):
             self.V = np.sqrt(self.Vm**2 + self.Vt**2)        
             self.Vr = self.Vm * np.sin(self.phi) 
             
-            self = compute_gas_constants(self)
+            compute_gas_constants(self)
             rho_mean = self.rho.mean()
             for i in range(len(self.massflow)-1):    
                 tube_massflow = self.massflow[i+1]-self.massflow[i]

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):

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
@@ -142,7 +142,31 @@ class Passage:
             
         return phi, rm, r
         
-    def get_cutting_line(self, t_hub:float) -> line2D:
+    def get_area(self,t_hub:float) -> float:
+        """Get Area
+
+        Args:
+            t_hub (float): Percent arc length along the hub 
+
+        Returns:
+            float: Area
+        """
+        n = 100
+        line = self.get_cutting_line(t_hub)[0]
+        x,r = line.get_point(np.linspace(0,1,n))
+        total_area = 0 
+        for j in range(1,n):
+            if np.abs((x[-1]-x[0]))<1E-12: # Axial Machines
+                total_area += np.pi*(r[j]**2-r[j-1]**2)
+            else:   # Radial Machines
+                dx = x[j]-x[j-1]
+                S = (r[j]-r[j-1])
+                C = np.sqrt(1+((r[j]-r[j-1])/dx)**2)
+                area = 2*np.pi*C*(S/2*dx**2+r[j-1]*dx)
+                total_area += area
+        return total_area
+        
+    def get_cutting_line(self, t_hub:float) -> Tuple[line2D,float,float]:
         """Gets the cutting line perpendicular to hub and shroud 
 
         Args:
@@ -188,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()
@@ -209,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 

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
@@ -79,7 +103,12 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
             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
+        
+        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])
 

turbodesign/solve_radeq.py

@@ -18,7 +18,8 @@ def adjust_streamlines(blade_rows:List[BladeRow],passage:Passage):
         passage (Passage): passage object describing the hub and shroud 
 
     """
-    for _,row in enumerate(blade_rows):
+    for row_index,row in enumerate(blade_rows):
+        print(f"Adjusting Streamlines to balance massflow Row: {row_index}")
         massflow_fraction =  np.linspace(0,1,len(row.percent_hub_shroud))
         row.total_massflow = row.massflow[-1]
         ideal_massflow_fraction = row.massflow[-1] * massflow_fraction
@@ -26,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))

turbodesign/spool.py

@@ -1,7 +1,7 @@
 # type: ignore[arg-type, reportUnknownArgumentType]
 from dataclasses import field
 import json
-from typing import Dict, List, Union
+from typing import Dict, List, Union, Optional
 import matplotlib.pyplot as plt
 from .bladerow import BladeRow
 import numpy as np
@@ -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.
         """
@@ -70,13 +70,12 @@ class Spool:
                 2. Counter Rotation: We either use the RPM already persecribed for each blade row.
             '''    
             if (type(self.blade_rows[i]) != Inlet) and (type(self.blade_rows[i]) != Outlet):
-                self.blade_rows[i].fluid = self.fluid
                 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
-    def fluid(self):
+    def fluid(self) -> Optional[Solution]:
         return self._fluid
 
     @fluid.setter
@@ -159,13 +158,15 @@ 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 (row.loss_function == None):  
-                row.loss_function = TD2()
+            if (type(row)!= Inlet and type(row) != Outlet):  
+                if row.loss_function == None:
+                    row.loss_function = TD2()
             
     def calculate_streamline_curvature(self,row:BladeRow,t_radial:Union[List[float],npt.NDArray]):
         """Called to calculate new streamline curvature
@@ -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))

turbodesign/td_math.py

@@ -6,6 +6,7 @@ from .bladerow import BladeRow, compute_gas_constants
 from .enums import RowType, LossType
 from scipy.integrate import trapezoid
 from .passage import Passage
+from .isentropic import IsenP
 
 def T0_coolant_weighted_average(row:BladeRow) -> float:
     """Calculate the new weighted Total Temperature array considering coolant
@@ -17,11 +18,12 @@ def T0_coolant_weighted_average(row:BladeRow) -> float:
     Returns:
         float: Total Temperature drop
     """
-    row.coolant.fluid.TP = row.coolant.T0, row.coolant.P0
+    
     massflow = row.massflow
     total_massflow_no_coolant = row.total_massflow_no_coolant
     Cp = row.Cp
-    Cpc = row.coolant.fluid.cp
+    
+    Cpc = row.coolant.Cp
     T0c = row.coolant.T0
     massflow_coolant = row.coolant.massflow_percentage*total_massflow_no_coolant*row.massflow[1:]/row.massflow[-1] 
     if massflow_coolant.mean()>0:
@@ -35,8 +37,9 @@ def T0_coolant_weighted_average(row:BladeRow) -> float:
         else:
             T0R = row.T0R
             T0R_new = T0R.copy()
+            Cp = row.Cp
             T0R_new[1:] = (massflow[1:]*Cp*T0R[1:] + massflow_coolant*Cpc*T0c) \
-                        /(massflow[1:]*row.fluid.cp + massflow_coolant*Cpc)
+                        /(massflow[1:]*Cp + massflow_coolant*Cpc)
             T0R_new[0] = T0R_new[1]
             
             T = T0R_new - row.W**2/(2*Cp)   # Dont change the velocity triangle but adjust the static temperature 
@@ -61,7 +64,7 @@ def compute_massflow(row:BladeRow) -> None:
     for j in range(1,len(row.percent_hub_shroud)):
         Vm = (row.Vm[j]+row.Vm[j-1])/2
         rho = (row.rho[j]+row.rho[j-1])/2
-        if np.abs((row.x[j]-row.x[j-1]))<1E-12: # Axial Machines
+        if np.abs((row.x[j]-row.x[j-1]))<1E-5: # Axial Machines
             total_area += np.pi*(row.r[j]**2-row.r[j-1]**2)
             massflow[j] = Vm * rho * np.pi* (row.r[j]**2-row.r[j-1]**2) + massflow[j-1]
         else:   # Radial Machines
@@ -77,6 +80,7 @@ def compute_massflow(row:BladeRow) -> None:
         massflow += massflow_fraction*row.coolant.massflow_percentage*row.total_massflow_no_coolant    # Take into account the coolant massflow
     row.massflow = massflow
     row.calculated_massflow = massflow[-1]
+    row.total_massflow = massflow[-1]
     row.area = total_area
 
 def compute_reynolds(rows:List[BladeRow],passage:Passage):
@@ -89,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))
@@ -107,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
 
@@ -125,11 +127,14 @@ def compute_power(row:BladeRow,upstream:BladeRow) -> None:
         row.T_is = 0 
         row.T0_is = 0
     else:
-        row.T_is = row.T0R*(row.P/upstream.P0R)**((row.gamma-1)/row.gamma)
-        row.T0_is = row.T_is*(1+(row.gamma-1)/2*row.M**2)
+        P0_P = (upstream.P0/row.P).mean()
+        row.T_is = upstream.T0 * (1/P0_P)**((row.gamma-1)/row.gamma)
+        a = np.sqrt(row.gamma*row.R*row.T_is)
+        row.T0_is = row.T_is * (1+(row.gamma-1)/2*(row.V/a)**2)
+        
         row.power = row.massflow[-1] * row.Cp * (upstream.T0.mean() - row.T0.mean())
-        row.eta_static = row.power/ (row.massflow[-1]*row.Cp*(upstream.T0.mean()-row.T0_is.mean()))
-        row.eta_total = row.power / (row.massflow[-1]*row.Cp * (upstream.T0.mean()-row.T0_is.mean()))
+        row.eta_static = row.power/ (row.massflow[-1]*row.Cp*(upstream.T0.mean()-row.T_is.mean()))
+        row.eta_total = (upstream.T0.mean() - row.T0.mean()) / (upstream.T0.mean() - row.T0_is.mean())
         row.stage_loading = row.Cp*(upstream.T0.mean() - row.T0.mean())/row.U.mean()**2
         row.euler_power = row.massflow[-1]* (upstream.U*upstream.Vt - row.U*row.Vt).mean()
     
@@ -150,7 +155,7 @@ def compute_quantities(row:BladeRow,upstream:BladeRow):
     if row.row_type == RowType.Rotor:
         Cp_avg = (row.Cp+upstream.Cp)/2
         # Factor any coolant added and changes in streamline radius
-        row.T0R = upstream.T0R - T0_coolant_weighted_average(row) - (upstream.U**2-row.U**2)/(2*Cp_avg) 
+        row.T0R = upstream.T0R - T0_coolant_weighted_average(row) # - (upstream.U**2-row.U**2)/(2*Cp_avg) 
         row.P = upstream.P0_stator_inlet/row.P0_P
         
         if row.loss_function.loss_type == LossType.Pressure: 
@@ -225,20 +230,21 @@ 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:
         row.M = ((row.P0/row.P)**((row.gamma-1)/row.gamma) - 1) * 2/(row.gamma-1)
         row.M = np.sqrt(row.M)
-        T0_T = (1+(row.gamma-1)/2 * row.M.mean()**2)
+        T0_T = (1+(row.gamma-1)/2 * row.M**2)
         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)
+        row.Vm = row.V*np.cos(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)
+        row.Vr = row.Vm*np.sin(row.phi)
         row.Vt = row.Vm*np.tan(row.alpha2)
     else: # We know Vm, P0, T0, P
         row.Vx = row.Vm*np.cos(row.phi)
@@ -254,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):
@@ -297,7 +304,7 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
         row.W = np.sqrt(2*row.Cp*(row.T0R-row.T)) #! nan popups here a lot for radial machines 
         if np.isnan(np.sum(row.W)):
             # Need to adjust T
-            print(f'nan detected: check flow path. Turbine inlet cut should be horizontal')
+            raise ValueError(f'nan detected: check flow path. Turbine inlet cut should be horizontal')
         row.Vr = row.W*np.sin(row.phi)
         row.Vm = row.W*np.cos(row.beta2)
         row.Wt = row.W*np.sin(row.beta2)
@@ -327,11 +334,6 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
     
     row.M_rel = row.W/np.sqrt(row.gamma*row.R*row.T)
     row.T0 = row.T+row.V**2/(2*row.Cp)
-    
-    T3_is = upstream.T0 * (1/row.P0_P)**((row.gamma-1)/row.gamma)
-    a = np.sqrt(row.gamma*row.R*T3_is)
-    T03_is = T3_is * (1+(row.gamma-1)/2*(row.V/a)**2)
-    row.eta_total = (upstream.T0.mean() - row.T0.mean())/(upstream.T0.mean()-T03_is.mean())
 
 def inlet_calc(row:BladeRow):
     """Calculates the conditions for the Inlet 
@@ -339,12 +341,13 @@ def inlet_calc(row:BladeRow):
     Args:
         row (BladeRow): _description_
     """
+    
     area = row.Vm.copy()*0
     # Estimate the density
     row.T = row.T0
-    row.P = row.P0 
+    row.P = row.P0
     row.rho = row.P/(row.T*row.R)
-    total_area = 0 
+    total_area = 0
     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]
@@ -361,9 +364,9 @@ def inlet_calc(row:BladeRow):
                 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}")
+            raise ValueError(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}")
+            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)

turbodesign/turbinespool.py

@@ -10,17 +10,18 @@ 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, compute_reynolds
 from .solve_radeq import adjust_streamlines, radeq
-from scipy.optimize import minimize_scalar, minimize, fmin_slsqp
+from scipy.optimize import minimize_scalar, differential_evolution, fmin_slsqp
 from .inlet import Inlet
 from .outlet import Outlet
 
 class TurbineSpool(Spool):
+    
     def __init__(self,passage:Passage,
                  massflow:float,rows:List[BladeRow],
                  num_streamlines:int=3,
                  fluid:Solution=Solution('air.yaml'),
                  rpm:float=-1,
-                massflow_constraint:MassflowConstraint=MassflowConstraint.MatchMassFlow):
+                 massflow_constraint:MassflowConstraint=MassflowConstraint.MatchMassFlow):
         """Initializes a Turbine Spool
 
         Args:
@@ -45,21 +46,22 @@ class TurbineSpool(Spool):
         # Inlet
         W0 = self.massflow
         inlet = self.blade_rows[0]
-        if self.blade_rows[0].row_type == RowType.Inlet:
-            self.blade_rows[0].massflow = np.linspace(0,1,self.num_streamlines)*W0
-            self.blade_rows[0].total_massflow = W0 
-            self.blade_rows[0].total_massflow_no_coolant = W0 
-            
-            interpolate_streamline_radii(self.blade_rows[0],self.passage,self.num_streamlines)
+        if self.fluid:
+            inlet.initialize_fluid(self.fluid)
+        else:
+            inlet.initialize_fluid(R=self.blade_rows[1].R,
+                                    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)
 
-            # Set the gas to total values for now             
-            self.blade_rows[0].fluid.TP = self.blade_rows[0].T0.mean(), self.blade_rows[0].P0.mean()
-            self.blade_rows[0].Cp = self.blade_rows[0].fluid.cp
-            self.blade_rows[0].Cv = self.blade_rows[0].fluid.cv
-            self.blade_rows[0].R = self.blade_rows[0].Cp-self.blade_rows[0].Cv
-            self.blade_rows[0].gamma = self.blade_rows[0].Cp/self.blade_rows[0].Cv
-            self.blade_rows[0].rho[:] = self.blade_rows[0].fluid.density
-            inlet_calc(self.blade_rows[0])
+        compute_gas_constants(inlet,self.fluid)
+        inlet_calc(inlet)
         
         for row in self.blade_rows:
             interpolate_streamline_radii(row,self.passage,self.num_streamlines)
@@ -83,10 +85,10 @@ class TurbineSpool(Spool):
             
             row = self.blade_rows[i]
             if (row.coolant is not None):
-                T0c = self.blade_rows[i].coolant.fluid.T
-                P0c = self.blade_rows[i].coolant.fluid.P
+                T0c = self.blade_rows[i].coolant.T0
+                P0c = self.blade_rows[i].coolant.P0
                 W0c = self.blade_rows[i].coolant.massflow_percentage * self.massflow
-                Cpc = self.blade_rows[i].coolant.fluid.cp
+                Cpc = self.blade_rows[i].coolant.Cp
             else:
                 T0c = 100
                 P0c = 0
@@ -120,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):
         """
@@ -133,9 +137,9 @@ class TurbineSpool(Spool):
         self.initialize_quantities()
         
         if self.massflow_constraint ==MassflowConstraint.MatchMassFlow:
-            self.__match_massflow()
+            self.__match_massflow()  # Matches massflow by changing turning angle
         elif self.massflow_constraint == MassflowConstraint.BalanceMassFlow:
-            self.__balance_massflow()
+            self.__balance_massflow()   # Balances massflow by changing row exit static pressure
 
     
     def __match_massflow(self):
@@ -161,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
@@ -169,14 +173,41 @@ class TurbineSpool(Spool):
                         elif row.row_type == RowType.Stator:
                             row.alpha2[j] = np.radians(res.x)
                             row.alpha2[0] = 1/(len(row.alpha2)-1)*row.alpha2[1:].sum()
-                    upstream = compute_gas_constants(upstream)
-                    row = compute_gas_constants(row)
+                    compute_gas_constants(upstream,self.fluid)
+                    compute_gas_constants(row,self.fluid)
                 
                     
             # 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.
 
@@ -193,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):
@@ -232,27 +246,29 @@ class TurbineSpool(Spool):
             Returns:
                 _type_: _description_
             """
+            blade_rows_backup = copy.deepcopy(blade_rows)
             # try:
             if balance_mean_pressure:
-                for j in range(self.num_streamlines):                
+                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 
-                
-            calculate_massflows(blade_rows,True)
+            # try:  
+            calculate_massflows(blade_rows,True,self.fluid)
             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
+            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
+            
+
         # 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 
         
@@ -260,60 +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:
-            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})
-            x = res.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
-        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 
@@ -327,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()
@@ -342,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)
@@ -368,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,
@@ -389,7 +385,7 @@ class TurbineSpool(Spool):
             json.dump(data, f, indent=4,cls=NumpyEncoder)
 
 
-def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
+def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False,fluid:Solution=None):
     """Calculates the massflow 
 
     Args:
@@ -398,7 +394,7 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
         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:
@@ -407,8 +403,6 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
                 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:
@@ -420,16 +414,16 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
                         if row.row_type == RowType.Rotor:
                             rotor_calc(row,upstream,calculate_vm=True)
                             # Finds Equilibrium between Vm, P0, T0
-                            row = radeq(row,upstream) 
-                            row = compute_gas_constants(row)
+                            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 = compute_gas_constants(row)
+                            row = radeq(row,upstream,downstream)
+                            compute_gas_constants(row,fluid)
                             stator_calc(row,upstream,downstream,calculate_vm=False)
-                        row = compute_gas_constants(row)
+                        compute_gas_constants(row,fluid)
                         compute_massflow(row)
                         compute_power(row,upstream)
                         
@@ -442,7 +436,7 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
                             row.Yp = Yp
                             rotor_calc(row,upstream,calculate_vm=True)
                             row = radeq(row,upstream)
-                            row = compute_gas_constants(row)
+                            compute_gas_constants(row,fluid)
                             rotor_calc(row,upstream,calculate_vm=False)
                             return abs(row.eta_total - eta_total)
                         
@@ -452,13 +446,13 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
                         row.Yp = 0
                         stator_calc(row,upstream,downstream,calculate_vm=True)
                         row = radeq(row,upstream) 
-                        row = compute_gas_constants(row)
+                        row = compute_gas_constants(row,fluid)
                         stator_calc(row,upstream,downstream,calculate_vm=False)
-                    row = compute_gas_constants(row)
+                    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):
+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 
 
     Args:
@@ -483,8 +477,8 @@ def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:Blad
             elif row.row_type == RowType.Stator:
                 row.alpha2[index] = np.radians(exit_angle)
                 stator_calc(row,upstream,downstream)
-            upstream = compute_gas_constants(upstream)
-            row = compute_gas_constants(row)
+            upstream = compute_gas_constants(upstream,fluid)
+            row = compute_gas_constants(row,fluid)
         elif row.loss_function.loss_type == LossType.Enthalpy:
             # Search for pressure loss that results in the correct total temperature drop
             if row.row_type == RowType.Rotor:
@@ -496,8 +490,8 @@ def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:Blad
                 def find_yp(Yp):
                     row.Yp = Yp
                     rotor_calc(row,upstream)
-                    upstream = compute_gas_constants(upstream)
-                    row = compute_gas_constants(row)
+                    upstream = compute_gas_constants(upstream,fluid)
+                    row = compute_gas_constants(row,fluid)
                     return abs(row.T0.mean() - T0_target)
                 res = minimize_scalar(find_yp,bounds=[0,0.6])
                 row.Yp = res.x
@@ -505,8 +499,8 @@ def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:Blad
                 row.Yp = 0
                 row.alpha2[index] = np.radians(exit_angle)
                 stator_calc(row,upstream,downstream)
-                upstream = compute_gas_constants(upstream)
-                row = compute_gas_constants(row)
+                upstream = compute_gas_constants(upstream,fluid)
+                row = compute_gas_constants(row,fluid)
         
 
     # if use_radeq:
@@ -516,12 +510,12 @@ def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:Blad
     compute_power(row,upstream)
     
     if row.row_type!=RowType.Inlet:
-        if row.row_type == RowType.Rotor:
-            T3_is = upstream.T0 * (1/row.P0_P)**((row.gamma-1)/row.gamma)
-        else:
-            T3_is = upstream.T0 * (row.P0/row.P)**((row.gamma-1)/row.gamma)
+        # if row.row_type == RowType.Rotor:
+        T3_is = upstream.T0 * (1/row.P0_P)**((row.gamma-1)/row.gamma)
+        # else:
+        #     T3_is = upstream.T0 * (row.P0/row.P)**((row.gamma-1)/row.gamma)
         a = np.sqrt(row.gamma*row.R*T3_is)
-        T03_is = T3_is * (1+(row.gamma-1)/2*(row.Vm/a)**2)
+        T03_is = T3_is * (1+(row.gamma-1)/2*(row.V/a)**2)
         row.eta_total = (upstream.T0.mean() - row.T0.mean())/(upstream.T0.mean()-T03_is.mean())
         
     return np.abs(row.total_massflow*index/(len(row.massflow)-1) - row.massflow[index])