turbo-design 1.0.1__py3-none-any.whl

turbodesign/spool.py

@@ -0,0 +1,289 @@
+# type: ignore[arg-type, reportUnknownArgumentType]
+from dataclasses import field
+import json
+from typing import Dict, List, Union
+import matplotlib.pyplot as plt
+from .bladerow import BladeRow
+import numpy as np
+import numpy.typing as npt
+from .enums import RowType, MassflowConstraint
+from cantera.composite import Solution
+from .loss.turbine import TD2
+from pyturbo.helper import line2D
+from scipy.interpolate import interp1d
+from .passage import Passage
+from .inlet import Inlet
+from .outlet import Outlet 
+
+class Spool:
+    blade_rows: List[BladeRow] = []
+    massflow:float=0
+    rpm:float = 0
+    
+    passage:Passage
+    t_streamline: npt.NDArray = field(default_factory=lambda: np.zeros((10,)))
+    num_streamlines:int=0
+    
+    # Fluid entering the spool
+    _fluid: Solution = Solution("air.yaml")
+
+    massflow_constraint: MassflowConstraint
+    
+    # Inlet Conditions 
+    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):
+        """Initializes a Spool
+
+
+        Note:
+            When it comes to massflow, the exit angle of the blade rows along with the upstream total pressure is used to set the massflow through the spool. If turning is too high then massflow is limited and cannot. 
+            This code gives you the option of setting a massflow and varying the exit angles to match that particular massflow. (MatchMassflow)
+            Or keeping the exit angle and modifying the inlet condition to set a specific massflow through the stage. (BalanceMassflow)
+            
+        Args:
+            passage (Passage): Passage defining hub and shroud
+            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').
+            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.
+        """
+        self.passage = passage
+        self.fluid = fluid
+        self.massflow = massflow
+        self.num_streamlines = num_streamlines
+        self.blade_rows = rows
+        self.massflow_constraint = massflow_constraint
+        
+        self.rpm = rpm
+        
+        for i in range(len(self.blade_rows)):
+            '''Defining RPM in the bladerows
+                There's 2 ways of setting the RPM. 
+                1. Conventional: Stator-Rotor-Stator-Rotor-etc. Set the RPM equally across all
+                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
+            
+
+    @property
+    def fluid(self):
+        return self._fluid
+
+    @fluid.setter
+    def fluid(self,newFluid:Solution):
+        """Change the type of gas used in the spool
+
+        Args:
+            new_gas (ct.Solution.Solution): New gas mixture
+        """
+        self._fluid = newFluid
+
+
+    def set_blade_row_rpm(self,index:int,rpm:float):
+        """sets the rpm of a particular blade row"""    
+        self.blade_rows[index].rpm = rpm
+        
+    def set_blade_row_type(self,blade_row_index:int,rowType:RowType):
+        """Sets a blade row to be a different type.
+
+        Args:
+            blade_row_index (int): Index of blade row. Keep in mind Blade row 0 is inlet, -1 = outlet
+        """
+        self.blade_rows[blade_row_index].row_type = rowType
+
+    def set_blade_row_exit_angles(self,radius:Dict[int,List[float]],beta:Dict[int,List[float]],IsSupersonic:bool=False):
+        """Set the intended exit flow angles for the spool. 
+
+            Useful if you already have a geometry that you want to simulate
+            
+            You can set the values for each blade row or simply the inlet and exit
+ 
+        Args:
+            radius (np.ndarray): Matrix containing [[r1,r2,r3],[r1,r2,r3]] blade_rows x radial locations
+            beta (Dict[int,List[float]]): Metal Angle of the geometry, it is assumed that the fluid will leave at this angle.
+            IsSupersonic(bool): if solution is supersonic at spool exit
+
+        Example: 
+            # Station 0 has angles of [73.1,74.2,75.4] 
+            # Station 5 has angles of [69,69,69] 
+            beta =  {0: [73.1,74.2,75.4],
+                      5: [69,69,69]}
+
+        """
+        for k,v in radius.items():                                   
+            self.blade_rows[k].radii_geom = v 
+        for k,v in beta.items():                                   
+            self.blade_rows[k].beta_geom = v 
+            self.blade_rows[k].beta_fixed = True
+        for br in self.blade_rows:
+            if not IsSupersonic:
+                br.solution_type = SolutionType.subsonic
+            else:
+                br.solution_type = SolutionType.supersonic
+        
+    
+    def initialize_streamlines(self):
+        """Initialize streamline and compute the curvature. 
+            This function is called once
+        """
+             
+        for row in self.blade_rows: 
+            row.phi = np.zeros((self.num_streamlines,))
+            row.rm = np.zeros((self.num_streamlines,))
+            row.r = 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()
+            
+    def calculate_streamline_curvature(self,row:BladeRow,t_radial:Union[List[float],npt.NDArray]):
+        """Called to calculate new streamline curvature
+
+        Args:
+            row (BladeRow): blade row
+            t_radial (Union[List[float],npt.NDArray]): normalized streamline radial locations
+        """
+        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))
+          
+    def solve(self):
+        raise NotImplementedError('Solve is not implemented')
+
+    
+    def plot(self):
+        """Plots the hub, shroud, and all the streamlines
+        """
+        plt.figure(num=1,clear=True,dpi=150,figsize=(15,10))
+        plt.plot(self.passage.xhub_pts,self.passage.rhub_pts,label='hub',linestyle='solid',linewidth=2,color='black')
+        plt.plot(self.passage.xshroud_pts,self.passage.rshroud_pts,label='shroud',linestyle='solid',linewidth=2,color='black')
+        
+        hub_length = np.sum(np.sqrt(np.diff(self.passage.xhub_pts)**2 + np.diff(self.passage.rhub_pts)**2))
+        # Populate the streamlines 
+        x_streamline = np.zeros((self.num_streamlines,len(self.blade_rows)))
+        r_streamline = np.zeros((self.num_streamlines,len(self.blade_rows)))
+        for i in range(len(self.blade_rows)):
+            x_streamline[:,i] = self.blade_rows[i].x
+            r_streamline[:,i] = self.blade_rows[i].r
+        
+        for i in range(1,len(self.blade_rows)-1): # plot dashed lines for each steamline
+            plt.plot(x_streamline[:,i],r_streamline[:,i],'--b',linewidth=1.5)
+        
+        for i in range(len(self.blade_rows)):
+            
+            row = self.blade_rows[i]
+            plt.plot(row.x,row.r,linestyle='dashed',linewidth=1.5,color='blue',alpha=0.4)
+            plt.plot(x_streamline[:,i],r_streamline[:,i],'or')
+            
+            if i == 0: 
+                pass # Inlet 
+            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)
+                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)
+                
+            if self.blade_rows[i].row_type == RowType.Stator:
+                x1,r1 = cut_line1.get_point(np.linspace(0,1,10))
+                plt.plot(x1,r1,'m')
+                x2,r2 = cut_line2.get_point(np.linspace(0,1,10))
+                plt.plot(x2,r2,'m')
+                x_text = (x1+x2)/2; r_text = (r1+r2)/2
+                plt.text(x_text.mean(),r_text.mean(),"Stator",fontdict={"fontsize":"xx-large"})
+            elif self.blade_rows[i].row_type == RowType.Rotor:
+                x1,r1 = cut_line1.get_point(np.linspace(0,1,10))
+                plt.plot(x1,r1,color='brown')
+                x2,r2 = cut_line2.get_point(np.linspace(0,1,10))
+                plt.plot(x2,r2,color='brown')
+                x_text = (x1+x2)/2; r_text = (r1+r2)/2
+                plt.text(x_text.mean(),r_text.mean(),"Rotor",fontdict={"fontsize":"xx-large"})
+        plt.axis('scaled')
+        plt.savefig(f"Meridional.png",transparent=False,dpi=150)
+        plt.show()
+        
+    def plot_velocity_triangles(self):
+        """Plots the velocity triangles for each blade row
+            Made for turbines 
+        """
+        prop = dict(arrowstyle="-|>,head_width=0.4,head_length=0.8",
+            shrinkA=0,shrinkB=0)
+        
+        
+        for j in range(self.num_streamlines):
+            x_start = 0
+            y_max = 0; y_min = 0
+            plt.figure(num=1,clear=True)
+            for i in range(1,len(self.blade_rows)):
+                row = self.blade_rows[i]
+                x_end = x_start + row.Vx.mean()
+                dx = x_end - x_start
+                
+                Vt = row.Vt[j]
+                Wt = row.Wt[j]
+                U = row.U[j]
+
+                y_max = (Vt if Vt>y_max else y_max)
+                y_max = (Wt if Wt>y_max else y_max)
+                
+                y_min = (Vt if Vt<y_min else y_min)
+                y_min = (Wt if Wt<y_min else y_min)
+                
+                # V 
+                plt.annotate("", xy=(x_end,Vt), xytext=(x_start,0), arrowprops=prop)
+                plt.text((x_start+x_end)/2,Vt/2*1.1,"V",fontdict={"fontsize":"xx-large"})
+                
+                # W
+                plt.annotate("", xy=(x_end,Wt), xytext=(x_start,0), arrowprops=prop)
+                plt.text((x_start+x_end)/2,Wt/2*1.1,"W",fontdict={"fontsize":"xx-large"})
+                
+                if (abs(row.Vt[j]) > abs(row.Wt[j])):
+                    # Shift Vt to right just a bit so we can see it
+                    plt.annotate("", xy=(x_end,Wt), xytext=(x_end,0), arrowprops=prop) # Wt
+                    plt.text(x_end+dx*0.1,Wt/2,"Wt",fontdict={"fontsize":"xx-large"})
+
+                    plt.annotate("", xy=(x_end,U+Wt), xytext=(x_end,Wt), arrowprops=prop) # U
+                    plt.text(x_end+dx*0.1,(Wt+U)/2,"U",fontdict={"fontsize":"xx-large"})
+                else:
+                    # Shift Wt to right just a bit so we can see it
+                    plt.annotate("", xy=(x_end,Vt), xytext=(x_end,0), arrowprops=prop) # Vt
+                    plt.text(x_end+dx*0.1,Vt/2,"Vt",fontdict={"fontsize":"xx-large"})
+
+                    plt.annotate("", xy=(x_end,Wt+U), xytext=(x_end,Wt), arrowprops=prop) # U
+                    plt.text(x_end+dx*0.1,Wt+U/2,"U",fontdict={"fontsize":"xx-large"})
+
+                plt.text((x_start+x_end)/2,-y_max*0.95,row.row_type.name,fontdict={"fontsize":"xx-large"})
+                x_start += row.Vx[j]
+                plt.axis([0,x_end+dx, y_min, y_max])
+            plt.title(f"Velocity Triangles for Streamline {j}")
+            plt.savefig(f"streamline_{j:04d}.png",transparent=False,dpi=150)
+    
+
+
+   
+    
+def JSON_to_Spool(filename:str="spool.json"):
+    """Reads a JSON file with the properties 
+    #! Need to instantiate and return spool. Fluid isn't loaded fyi 
+
+    Args:
+        filename (str, optional): json filename with properties . Defaults to "spool.json".
+    """
+    with open(filename, "r") as f:
+        data = json.load(f)

turbodesign/stage.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass,field
+
+@dataclass
+class Stage :
+    blade_rows: list = None
+    cp: float = None
+    streamlines:list = field(default_factory=list)

turbodesign/td_math.py

@@ -0,0 +1,388 @@
+from typing import List, Tuple
+import numpy as np
+import math
+import numpy.typing as npt
+from .bladerow import BladeRow, compute_gas_constants
+from .enums import RowType, LossType
+
+def T0_coolant_weighted_average(row:BladeRow) -> float:
+    """Calculate the new weighted Total Temperature array considering coolant
+
+    Args:
+        coolant (Coolant): Coolant
+        massflow (np.ndarray): massflow mainstream
+
+    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
+    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:
+        if row.row_type == RowType.Stator:
+            T0= row.T0
+            dT0 = T0.copy() * 0 
+            T0_new = (massflow[1:]*Cp*T0[1:] + massflow_coolant*Cpc*T0c) \
+                        /(massflow[1:]*Cp + massflow_coolant*Cpc)
+            dT0[1:] = T0_new - row.T0[1:]
+            dT0[0] = dT0[1]
+        else:
+            T0R = row.T0R
+            T0R_new = T0R.copy()
+            T0R_new[1:] = (massflow[1:]*Cp*T0R[1:] + massflow_coolant*Cpc*T0c) \
+                        /(massflow[1:]*row.fluid.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 
+            T0_new = T+row.V**2/(2*Cp)      # Use new static temperature to calculate the total temperature 
+            dT0 = T0_new - row.T0
+        return dT0
+    else:
+        return row.T0*0
+
+def compute_massflow(row:BladeRow) -> None:
+    """Populates row.massflow and row.calculated_massflow 
+
+    Calculated_massflow is massflow[-1]
+
+    Args:
+        row (BladeRow): current blade row. All quantities are at exit
+        upstream (BladeRow): upstream blade row. All quantities are at exit
+    """
+    massflow_fraction =  np.linspace(0,1,len(row.percent_hub_shroud))
+    massflow = row.percent_hub_shroud*0
+    total_area = 0 
+    for j in range(1,len(row.percent_hub_shroud)):
+        Vm = row.Vm[j]
+        rho = row.rho[j]
+        if np.abs((row.x[j]-row.x[j-1]))<1E-12: # 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
+            dx = row.x[j]-row.x[j-1]
+            S = (row.r[j]-row.r[j-1])
+            C = np.sqrt(1+((row.r[j]-row.r[j-1])/dx)**2)
+            area = 2*np.pi*C*(S/2*dx**2+row.r[j-1]*dx)
+            total_area += area
+            massflow[j] = Vm * rho *area + massflow[j-1]
+    
+    row.total_massflow_no_coolant = massflow[-1]
+    if row.coolant != 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.area = total_area
+
+def compute_power(row:BladeRow,upstream:BladeRow) -> None:
+    """Calculates the power
+
+    Args:
+        row (BladeRow): _description_
+        upstream (BladeRow): _description_
+    """
+    if row.row_type == RowType.Stator:
+        row.power = 0
+        row.eta_static = 0
+        row.eta_total = 0
+        row.stage_loading = 0
+        row.euler_power = 0
+        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)
+        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.stage_loading = row.Cp*(upstream.T0.mean() - row.T0.mean())/row.U.mean()**2
+        row.euler_power = (row.massflow[-1]*((row.U+upstream.U)/2).mean()*(upstream.Vt-row.Vt).mean())
+    
+def compute_quantities(row:BladeRow,upstream:BladeRow):
+    """Calculation of all quantites after radial equilibrium has been solved assuming we know the static pressure at the exit.
+
+    Note:
+        Radial Equilibrium gives P0, T0, Vm. This code assumes the loss either enthalpy or pressure loss has already been calculated 
+
+        compute_velocity has been called so we know W, Wt, V, Vt, U, M, M_rel
+
+        Static Pressure and Temperature should come from Total Temperature and Pressure + Velocity 
+    Args:
+        row (BladeRow): current blade row. All quantities are at exit
+        upstream (BladeRow): upstream blade row. All quantities are at exit
+    """
+
+    if row.row_type == RowType.Rotor:
+        Cp_avg = (row.Cp+upstream.Cp)/2
+        # 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.P = upstream.P0_stator_inlet/row.P0_P
+        
+        if row.loss_function.loss_type == LossType.Pressure: 
+            # This affects the velocity triangle
+            row.P0R = upstream.P0R - row.Yp*(upstream.P0R-row.P)
+            row.T = (row.P/row.P0R)**((row.gamma-1)/row.gamma) * row.T0R
+            row.T0 = (1+(row.gamma-1)/2 * row.M**2) * row.T
+            row.power_distribution = row.massflow * row.Cp * (upstream.T0 - row.T0)
+            row.power = np.trapz(row.power_distribution,row.r-row.r[0])
+            row.power_mean = row.massflow[-1] * row.Cp * (upstream.T0.mean()-row.T0.mean())
+
+        elif row.loss_function.loss_type == LossType.Enthalpy:
+            ' For Enthalpy related loss, assume the static quantities do not change '
+            row.T = (row.P/row.P0R)**((row.gamma-1)/row.gamma) * row.T0R
+            row.T0 = (1+(row.gamma-1)/2 * row.M**2) * row.T
+
+            def calculate_power(T0:npt.NDArray):
+                row.power_distribution = row.massflow * row.Cp * (upstream.T0 - T0)
+                row.power = np.trapz(row.power_distribution,row.r-row.r[0])
+                row.power_mean = row.massflow[-1] * row.Cp * (upstream.T0.mean() - T0.mean())
+
+                # Factor in T0R_drop. Convert T0R drop to absolute terms
+                T_drop = (upstream.T0R - row.T0R) - row.W**2/(2*row.Cp) # row.T0R contains the drop
+                T0_drop = T_drop*(1+(row.gamma-1)/2*row.M**2)
+
+                T0 = upstream.T0 - row.power/row.eta_total/(row.total_massflow*row.Cp) + T0_drop
+                return T0
+
+            T0 = row.T0.copy()
+            for _ in range(5):  # interate on the convergence of T0_drop
+                T0 = calculate_power(T0)
+
+            row.T0 = T0 
+            row.T = row.T0-row.W**2/(2*row.Cp)
+            row.P0R = row.P * (row.T0R/row.T)**((row.gamma)/(row.gamma-1))
+            row.P0 = row.P * (row.T0/row.T)**((row.gamma)/(row.gamma-1))
+            
+    elif row.row_type == RowType.Stator:
+        ' For the stator we already assume the upstream P0 already applied '
+        if row.loss_function == LossType.Pressure:
+            row.P0 = upstream.P0 - row.Yp*(upstream.P0-row.P)
+        else:
+            row.P0 = upstream.P0
+        row.T0 = upstream.T0 - T0_coolant_weighted_average(row)
+        row.T = row.T0 * (1+(row.gamma-1)/2*row.M**2)
+        row.P = row.P0 * (row.T/row.T0)**((row.gamma)/(row.gamma-1))
+        row.T0R = row.T + row.W**2 / (2*row.Cp)
+        row.P0R = row.P*(row.T0R/row.T)**((row.gamma)/(row.gamma-1))
+   
+def compute_quantities_power(row:BladeRow,upstream:BladeRow):
+    """Calculation of all quantites after radial equilibrium has been solved assuming we know the power at the exit
+        
+    Note:
+        Radial Equilibrium gives P0, T0, Vm. This code assumes the loss either enthalpy or pressure loss has already been calculated 
+
+        compute_velocity has been called so we know W, Wt, V, Vt, U, M, M_rel
+
+        Static Pressure and Temperature should come from Total Temperature and Pressure + Velocity 
+
+    Args:
+        row (BladeRow): current blade row. All quantities are at exit
+        upstream (BladeRow): upstream blade row. All quantities are at exit
+
+    """
+    if row.row_type == RowType.Rotor:
+        Cp_avg = (row.Cp+upstream.Cp)/2
+        row.T0R = upstream.T0R - T0_coolant_weighted_average(row) - (upstream.U**2-row.U**2)/(2*Cp_avg)
+
+        # Factor in T0R_drop. Convert T0R drop to absolute terms
+        T_drop = (upstream.T0R - row.T0R) - row.W**2/(2*row.Cp) # row.T0R contains the drop
+        T0_drop = T_drop*(1+(row.gamma-1)/2*row.M**2)
+
+        # Adjust Total Temperature to match power
+        T0 = upstream.T0 - row.power/row.eta_total/(row.total_massflow*row.Cp) + T0_drop
+
+        if row.loss_function == LossType.Pressure: 
+            row.P0R = upstream.P0R - row.Yp*(upstream.P0R-row.P)
+            row.T0 = T0
+            row.T = row.T0/(1+(row.gamma-1)/2*row.M**2) 
+            row.P = row.P0R*(row.T/row.T0R)**(row.gamma/(row.gamma-1))
+            
+        elif row.loss_function == LossType.Enthalpy:                
+            row.P0 = row.P*(T0/row.T)**(row.gamma/(row.gamma-1))
+            row.T = T0 - row.W**2/(2*row.Cp) + T_drop
+            row.T0 = T0
+            row.P = row.P0*(row.T0/row.T)**(row.gamma/(row.gamma-1))
+            row.P0R = row.P * (row.T0R/row.T)**((row.gamma)/(row.gamma-1))
+
+    elif row.row_type == RowType.Stator:        
+        row.T0 = upstream.T0 - T0_coolant_weighted_average(row)
+        if row.loss_function == LossType.Pressure:
+            row.P0 = upstream.P0 - row.Yp*(upstream.P0-row.P)
+        else:
+            row.P0 = upstream.P0
+        row.T = row.T0 * (1+(row.gamma-1)/2*row.M**2)
+        row.P = row.P0 * (row.T/row.T0)**((row.gamma)/(row.gamma-1))
+        row.T0R = row.T + row.W**2 / (2*row.Cp)
+        row.P0R = row.P*(row.T0R/row.T)**((row.gamma)/(row.gamma-1))
+
+def stator_calc(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None,calculate_vm:bool=True):
+    """Given P0, T0, P, alpha2 of stator calculate all other quantities
+
+    Usage:
+        Set row.P0 = upstream.P0 - any pressure loss
+        row.T0 = upstream.T0 - any cooling
+        row.P = row.rp*(row.P0 - rotor.P) + rotor.P 
+        Set alpha2 
+        
+    Args:
+        row (BladeRow): Stator Row
+        upstream (BladeRow): Stator or Rotor Row 
+        downstream (BladeRow): Stator or Rotor Row. Defaults to None
+         
+    """
+    ## degree of reaction (rp) is assumed 
+    # downstream.P = upstream.P0 * 1/downstream.P0_P 
+    # if downstream is not None:
+    #     # Use the upstream P0 value then later factor in the loss
+    #     row.P = downstream.rp*(upstream.P0 - downstream.P) + downstream.P
+    # else:
+    #     row.P = upstream.P    
+    
+    # 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.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)
+        row.T0 = upstream.T0 - T0_coolant_weighted_average(row)
+        row.T = row.T0/T0_T
+        row.V = row.M*np.sqrt(row.gamma*row.R*row.T)
+        VV = row.V*np.cos(row.phi)
+        row.Vx = VV*np.cos(row.alpha2)
+        row.Vt = VV*np.sin(row.alpha2)
+        row.Vr = row.V*np.sin(row.phi)
+        row.Vm = np.sqrt(row.Vx**2+row.Vr**2)
+    else: # We know Vm, P0, T0
+        row.Vx = row.Vm*np.cos(row.phi)
+        row.Vr = row.Vm*np.sin(row.phi)
+        row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)
+        row.V = np.sqrt(row.Vx**2 + row.Vr**2 + row.Vt**2)
+        for _ in range(3): # Mach is a function of T and T is a function of Mach
+            row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
+            T0_T = (1+(row.gamma-1)/2 * row.M**2)
+            row.P = row.P0 *(1/T0_T)**(row.gamma/(row.gamma-1))
+            row.T = row.T0 * (1/T0_T)
+        
+    if upstream.row_type == RowType.Rotor:
+        row.alpha1 = upstream.alpha2 # Upstream rotor absolute frame flow angle
+    row.beta1 = upstream.beta2
+    row.rho = row.P/(row.R*row.T)
+    row.U = row.omega*row.r
+    row.P0_stator_inlet = upstream.P0
+
+def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
+    """Calculates quantities given beta2 
+
+    Args:
+        row (BladeRow): Rotor Row
+        upstream (BladeRow): Stator Row or Rotor Row
+    """
+    row.P0_stator_inlet = upstream.P0_stator_inlet
+    ## P0_P is assumed 
+    # row.P = row.P0_stator_inlet*1/row.P0_P
+    
+    # Static Pressure is assumed
+    row.P0_P = row.P0_stator_inlet/row.P
+    upstream_radius = upstream.r
+    row.U = row.omega*row.r
+    # Upstream Relative Frame Calculations 
+    upstream.U = upstream.rpm*np.pi/30 * upstream_radius # rad/s 
+    upstream.Wt = upstream.Vt - upstream.U
+    upstream.W = np.sqrt(upstream.Vx**2 + upstream.Wt**2 + upstream.Vr**2)
+    upstream.beta2 = np.arctan2(upstream.Wt,upstream.Vx)
+    upstream.T0R = upstream.T+upstream.W**2/(2*upstream.Cp)
+    upstream.P0R = upstream.P * (upstream.T0R/upstream.T)**((upstream.gamma)/(upstream.gamma-1))      
+    upstream.M_rel = upstream.W/np.sqrt(upstream.gamma*upstream.R*upstream.T)
+    
+    upstream_rothalpy = upstream.T0R*upstream.Cp - 0.5*upstream.U**2 # H01R - 1/2 U1^2 
+
+    # Rotor Exit Calculations
+    row.beta1 = upstream.beta2
+    #row.Yp # Evaluated earlier 
+    row.P0R = upstream.P0R - row.Yp*(upstream.P0R-row.P)
+    
+    # Total Relative Temperature stays constant through the rotor. Adjust for change in radius from rotor inlet to exit
+    row.T0R = (upstream_rothalpy + 0.5*row.U**2)/row.Cp - T0_coolant_weighted_average(row) 
+    P0R_P = row.P0R / row.P
+    T0R_T = P0R_P**((row.gamma-1)/row.gamma)
+    row.T = (row.T0R/T0R_T)     # Exit static temperature
+    if calculate_vm:    # Calculates the T0 at the exit
+        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')
+        row.Vr = row.W*np.sin(row.phi)
+        row.Wt = np.sqrt(row.W**2 - row.Vr**2) * np.sin(row.beta2)
+        row.Vt = row.Wt + row.U 
+        ww = row.W*np.cos(row.phi)
+        row.Vx = ww*np.cos(row.beta2)
+        row.V = np.sqrt(row.Vr**2+row.Vt**2+row.Vx**2)
+        row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
+        row.Vm = np.sqrt(row.Vx**2+row.Vr**2)
+        row.T0 = row.T + row.V**2/(2*row.Cp)
+        row.P0 = row.P*(row.T0/row.T)**(row.gamma/(row.gamma-1))
+        row.alpha2 = np.arctan2(row.Vt,row.Vx)
+    else: # We know Vm, P0, T0
+        row.Vr = row.Vm*np.sin(row.phi)
+        row.Vx = row.Vm*np.cos(row.phi)
+        
+        row.W = np.sqrt(2*row.Cp*(row.T0R-row.T))
+        row.Wt = np.sqrt(row.W**2 - row.Vr**2) * np.sin(row.beta2) 
+        row.U = row.omega * row.r 
+        row.Vt = row.Wt+row.U
+        
+        row.alpha2 = np.arctan2(row.Vt,row.Vx)
+        row.V = np.sqrt(row.Vx**2 + row.Vr**2 + row.Vt**2)
+        
+        row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
+        T0_T = (1+(row.gamma-1)/2 * row.M**2)
+        row.P0 = row.P * T0_T**(row.gamma/(row.gamma-1))
+    
+    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 
+
+    Args:
+        row (BladeRow): _description_
+    """
+    area = row.Vm.copy()*0
+    row.T = row.T0
+    row.P = row.P0 
+    total_area = 0 
+    for _ in range(5): # Lets converge the Mach and Total and Static pressures
+        for j in range(1,len(row.percent_hub_shroud)):
+            rho = row.rho[j]
+            tube_massflow = row.massflow[j]-row.massflow[j-1]
+            if np.abs((row.x[j]-row.x[j-1]))<1E-12: # Axial Machines  
+                total_area += np.pi*(row.r[j]**2-row.r[j-1]**2)
+                row.Vm[j] = tube_massflow/(rho*np.pi*(row.r[j]**2-row.r[j-1]**2))
+            else:   # Radial Machines
+                dx = row.x[j]-row.x[j-1]
+                S = (row.r[j]-row.r[j-1])
+                C = np.sqrt(1+((row.r[j]-row.r[j-1])/dx)**2)
+                area[j] = 2*np.pi*C*(S/2*dx**2+row.r[j-1]*dx)
+                total_area += area[j]
+                row.Vm[j] = tube_massflow/(rho*area[j])
+        row.Vm[0] = 1/(len(row.Vm)-1)*row.Vm[1:].sum() # Initialize the value at the hub to not upset the mean
+        row.Vr = row.Vm*np.sin(row.phi)
+        row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)
+        row.V = np.sqrt(row.Vt**2+row.Vm**2)
+           
+        row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
+        row.T = row.T0 * 1/(1+(row.gamma-1)/2*row.M**2)
+        row.P = row.P0 * (row.T/row.T0)**(row.gamma/(row.gamma-1))
+        compute_gas_constants(row)