turbo-design 1.0.0__py2.py3-none-any.whl

turbodesign/compressorspool.py

@@ -0,0 +1,60 @@
+from typing import List
+from cantera import composite
+from cantera.composite import Solution
+from .bladerow import BladeRow,RowType
+from .spool import Spool
+import json
+
+class CompressorSpool(Spool):
+    def __init__(self,rhub:List[float],xhub:List[float],
+                 rshroud:List[float],xshroud:List[float],
+                 massflow:float,rows=List[BladeRow],
+                 num_streamlines:int=3,
+                 fluid:Solution=Solution('air.yaml'),rpm:float=-1):
+        """Initializes a Compressor Spool
+
+        Args:
+            rhub (List[float]): hub radius. Units meters
+            xhub (List[float]): x location of each hub radius station. Units meters
+            rshroud (List[float]): shroud radius. Units meters
+            xshroud (List[float]): x location of each shroud radius. Units meters
+            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.
+            power_target (float, optional): Sets a target power in kW
+        """
+        super().__init__(rhub, xhub, rshroud, xshroud, massflow, rows,num_streamlines, fluid, rpm)
+        
+        pass
+    
+    def export_properties(self,filename:str="compressor_spool.json"):
+        """Export the spool object to json 
+
+        Args:
+            filename (str, optional): name of export file. Defaults to "spool.json".
+        """
+        blade_rows = list()
+        total_total_efficiency = list() 
+
+        for indx,row in enumerate(self.blade_rows):
+            blade_rows.append(row.to_dict()) # Appending data 
+            if row.row_type == RowType.Stator:
+                pass
+        
+        data = {            
+            "blade_rows": blade_rows,
+            "massflow":self.massflow,
+            "rpm":self.rpm,
+            "r_streamline":self.r_streamline.tolist(),
+            "x_streamline":self.x_streamline.tolist(),
+            "rhub":self.rhub.tolist(),
+            "rshroud":self.rshroud.tolist(),
+            "xhub":self.xhub.tolist(),
+            "xshroud":self.xshroud.tolist(),
+            "num_streamlines":self.num_streamlines,
+        }
+        # Dump all the Python objects into a single JSON file.
+        with open(filename, "w") as f:
+            json.dump(data, f, indent=4)

turbodesign/coolant.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass, field
+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 
+    

turbodesign/enums.py

@@ -0,0 +1,36 @@
+from enum import Enum
+
+class LossType(Enum):
+    Pressure = 1
+    Enthalpy = 2
+    Entropy = 3
+
+class RowType(Enum):
+    Stator = 1
+    Rotor = 2 
+    CounterRotating = 2
+    Inlet = 3
+    Outlet = 4
+
+class MassflowConstraint(Enum):
+    MatchMassFlow:int = 1 # Changes the exit angles to match the massflow
+    BalanceMassFlow:int = 2 # Keeps the exit angle but balances the massflow between the stages as best it can. This will affect the static pressure at the stage exit
+
+class PowerType(Enum):
+    """The code for BladeRow will assume a PowerType automatically depending on what you specify. If you specify the blade row to have P0_P which is the stator inlet total pressure to rotor exit static pressure then that will be used to calculate all the quantities.
+    
+    Or if you specify the power for the blade row, the Total Temperature at Rotor Exit will change. 
+    
+    P0_P: Assumes a Total-Static Pressure Ratio. Using this method will not allow you to match a particular massflow 
+    
+    T0: Total Temperature at exit is specified based on power required
+    
+    """
+    # 
+    P0_P:int = 1 
+    T0:int = 2 
+
+
+class PassageType(Enum):
+    Centrifugal:int=0
+    Axial:int=1

turbodesign/inlet.py

@@ -0,0 +1,146 @@
+from dataclasses import dataclass, field
+from typing import List, Union
+from .enums import RowType
+from .bladerow import BladeRow, compute_gas_constants, interpolate_quantities
+from .arrayfuncs import convert_to_ndarray
+import numpy as np 
+from cantera import Solution
+from .passage import Passage
+from scipy.interpolate import interp1d
+import numpy.typing as npt 
+
+class Inlet(BladeRow):
+    """Station defined at Inlet
+
+    Inherits:
+        (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]):
+        """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
+            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
+        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)
+        # 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.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
+        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)
+        
+        
+    def initialize_velocity(self,passage:Passage,num_streamlines:int):
+        """Initialize velocity calculations. Assumes streamlines and inclination angles have been calculated 
+     
+        """
+        # 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)
+        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)
+
+            self.Vm = self.M**2 * self.gamma*self.R*self.T0/T0_T \
+                        / (1+np.cos(self.phi)**2 * np.tan(self.alpha1)**2)
+
+            self.Vm = np.sqrt(self.Vm)
+            self.T = self.T0/T0_T
+            self.P = self.P0/(T0_T)**(self.gamma/(self.gamma-1))
+            self.rho = self.P/(self.R*self.T)
+            
+            self.Vx = self.Vm * np.cos(self.phi)
+            self.Vt = self.Vm * np.cos(self.phi) * np.tan(self.beta1)
+            self.V = np.sqrt(self.Vm**2 + self.Vt**2)        
+            self.Vr = self.Vm * np.sin(self.phi) 
+            
+            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]
+                if np.abs((self.x[i]-self.x[i-1]))<1E-12: # Axial Machines
+                    self.Vm[i+1] = tube_massflow/(rho_mean*np.pi*(self.r[i+1]**2-self.r[i]**2))
+                else:   # Radial Machines
+                    dx = self.x[i]-self.x[i-1]
+                    S = (self.r[i]-self.r[i-1])
+                    C = np.sqrt(1+((self.r[i]-self.r[i-1])/dx)**2)
+                    area = 2*np.pi*C*(S/2*dx**2+self.r[i-1]*dx)
+                    self.Vm[i+1] = tube_massflow/(rho_mean*area)
+            self.Vm[0] = 1/(len(self.Vm)-1)*self.Vm[1:].sum()
+            
+            self.M = self.Vm /np.sqrt(self.gamma*self.R*self.T)
+            Vm_err = np.max(abs(self.Vm-Vm_prev)/self.Vm)
+            Vm_prev = self.Vm
+            if Vm_err < 1E-4:
+                break
+        
+        Area = 0
+        for j in range(1,num_streamlines):
+            if np.abs((self.x[j]-self.x[j-1]))<1E-12: # Axial Machines  
+                Area += np.pi*(self.r[j]**2-self.r[j-1]**2)
+            else:   # Radial Machines
+                dx = self.x[j]-self.x[j-1]
+                S = (self.r[j]-self.r[j-1])
+                C = np.sqrt(1+((self.r[j]-self.r[j-1])/dx)**2)
+                Area += 2*np.pi*C*(S/2*dx**2+self.r[j-1]*dx)
+                
+        self.calculated_massflow = self.rho.mean()*self.Vm.mean() * Area
+    
+
+    def get_total_pressure(self,percent_hub_shroud:Union[float,npt.NDArray]):
+        """Returns the static pressure at a certain percent hub_shroud
+
+        Args:
+            percent_hub_shroud (Union[float,npt.NDArray]): _description_
+
+        Returns:
+            _type_: _description_
+        """
+        if type(percent_hub_shroud) == float:
+            return float(self.P0_fun(percent_hub_shroud))
+        else:
+            return self.P0_fun(percent_hub_shroud)
+    
+    def get_total_temperature(self,percent_hub_shroud:Union[float,npt.NDArray]):
+        """Returns the static pressure at a certain percent hub_shroud
+
+        Args:
+            percent_hub_shroud (Union[float,npt.NDArray]): _description_
+
+        Returns:
+            _type_: _description_
+        """
+        if type(percent_hub_shroud) == float:
+            return float(self.T0_fun(percent_hub_shroud))
+        else:
+            return self.T0_fun(percent_hub_shroud)

turbodesign/isentropic.py

@@ -0,0 +1,82 @@
+import numpy as np
+import math
+
+
+def IsenP(M:np.ndarray,gamma:float) -> float:
+    """Computes the ratio P0/Ps
+
+    Args:
+        M (np.ndarray): Mach Number
+        gamma (float): specific heat ratio
+
+    Returns:
+        float: P0/P ratio 
+    """
+    return np.power((1+(gamma-1)/2.0 * M*M),gamma/(gamma-1))
+
+
+def FindMachP0P(P0_P:np.ndarray,gamma:float) -> float:
+    """Finds the mach number given a P0/P ratio
+
+    Args:
+        P0_P (np.ndarray): ratio of total to static pressure
+        gamma (float): specific heat ratio
+
+    Returns:
+        float: [description]
+    """
+    n = (gamma-1)/gamma
+    c = 2.0/(gamma-1) * (np.power(P0_P,n) - 1.0)
+
+    M = np.sqrt(c)
+    return M # Subsonic and supersonic solution
+    
+
+
+def IsenT(M:np.ndarray,gamma:float) -> float:
+    """Computes T0/Ts
+
+    Args:
+        M (np.ndarray): _description_
+        gamma (float): _description_
+
+    Returns:
+        float: Ratio of T0/Ts
+    """
+    return (1.0+(gamma-1.0)/2.0 *M*M)
+
+
+def A_As(M:np.ndarray,gamma:float) -> float:
+    """Computes the ratio of Area to Throat Area give a given mach number and gamma 
+
+    Args:
+        M (np.ndarray): Mach Number
+        gamma (float): Specific Heat Ratio 
+
+    Returns:
+        float: Area to throat area ratio 
+    """
+    a = (gamma+1.0)/(2.0*(gamma-1.0))
+    temp1 = np.power((gamma+1.0)/2.0,a)
+    temp2 = np.power((1+(gamma-1)/2*M*M),-a)/M
+    return temp1*temp2
+
+
+def Massflow(P0:float,T0:float,A:float,M:float,gamma:float,R:float=287):
+    """Massflow rate calculation
+    
+    Args:
+        P0 (float): Inlet Total Pressure (Pa)
+        T0 (float): Inlet Total Temperature (K)
+        A (float): Area (m^2)
+        M (float): Mach Number 
+        gamma (float): Ratio of specific heats
+        R (float): Ideal Gas Constant. Defaults to 287 J/(KgK).
+
+    Returns:
+        float: Nusselt Number
+    """
+    mdot = A * P0/np.sqrt(T0) * np.sqrt(gamma/R) * M \
+        *np.power(1.0+(gamma-1.0)/2.0 * M*M, -(gamma+1.0)/(2.0*(gamma-1.0)))
+    
+    return mdot

turbodesign/loss/__init__.py

@@ -0,0 +1 @@
+from .losstype import LossType, LossBaseClass

turbodesign/loss/compressor/__init__.py

@@ -0,0 +1 @@
+

turbodesign/loss/losstype.py

@@ -0,0 +1,25 @@
+from typing import Any, Dict
+from ..lossinterp import LossInterp
+import os 
+from ..enums import LossType
+
+class LossBaseClass:  
+    data: Dict[str,LossInterp]
+    _loss_type:LossType
+    
+    def __init__(self,lossType:LossType):
+        # Make the environment directory 
+        default_home = os.path.join(os.path.expanduser("~"), ".cache")
+        os.environ['TD3_HOME'] = os.path.join(default_home,'TD3_LossModels')
+        os.makedirs(os.environ['TD3_HOME'],exist_ok=True)
+        
+        self._loss_type = lossType
+
+    def __call__(self, row:Any, upstream:Any):
+        raise Exception("Method needs to be overridden")
+
+    
+    
+    @property
+    def loss_type(self):
+        return self._loss_type

turbodesign/loss/turbine/TD2.py

@@ -0,0 +1,142 @@
+import math
+from ...lossinterp import LossInterp
+from ...enums import RowType, LossType
+from typing import Any, Callable, Dict, List, Union 
+from ...bladerow import BladeRow
+from scipy.stats import linregress
+import numpy as np 
+from ..losstype import LossBaseClass
+
+
+class TD2(LossBaseClass):
+
+    
+    def __init__(self):
+        super().__init__(LossType.Pressure)
+
+        
+    @property
+    def LossType(self):
+        return self._loss_type
+    
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+        """TD2-2_Manual equations 12a and 12b. This is the loss equation used inside original TD2.
+        #! Wrong very wrong from the book definition
+        Total Pressure Loss (Y) = (P_in - P_ex) / (P_ex - P_ex,static)
+        Where P_in and P_ex are total quantities 
+        
+        Authors Comments:
+            Given the assumptions, the use of this loss correlation should be limited to starting a solution. 
+
+        Assumptions:
+            1. Rotor and stator loss coefficients were equal when their relative design requirements are identical 
+            2. Stage reaction at meanline is 50%
+            3. Axial velocity was constant through the stage
+            4. Stator exit Mach number is 0.8 
+
+        Args:
+            beta_in (float): Inlet flow angle in degrees. 
+            beta_ex (float): Exit flow angle in degrees.
+            V_ratio (float): Ratio if inlet velocity magnitude with relative exit velocity magnitude
+
+        Returns:
+            float: Total Pressure loss coefficient
+        """
+        beta_in = row.beta1.mean() # absolute flow angle entering the blade row
+        beta_ex = row.beta2.mean()  # flow angle leaving the blade row
+        if row.row_type == RowType.Stator:
+            V_ratio = row.V.mean() / upstream.V.mean()    # Vin/Vex Equation 12a and 12b. Relative to Stator
+        elif row.row_type == RowType.Rotor:
+            V_ratio = row.W.mean() /upstream.W.mean()     # Vin/Vex Equation 12a and 12b. Relative to Rotor 
+
+        a = [0.055, 0.15, 0.6, 0.6, 0.8, 0.03, 0.157255, 3.6] # Coefficients from pw3hp1.json
+        # mu should be in 
+        if V_ratio < a[2]: 
+            Y = abs(math.tan(beta_in) - math.tan(beta_ex)) / (a[3] + a[4]*math.cos(beta_ex)) * (a[5] + a[6]*V_ratio**a[7])
+        else:
+            Y = abs(math.tan(beta_in) - math.tan(beta_ex)) / (a[3] + a[4]*math.cos(beta_ex)) * (a[0] + a[1]*(V_ratio - a[2]))
+
+        return Y
+    
+class TD2_Reynolds_Correction(LossBaseClass):
+    
+    def __init__(self):
+        super().__init__(LossType.Pressure)
+
+        self.TD2 = TD2()
+    
+    @property
+    def LossType(self):
+        return self._loss_type
+    
+    def __call__(self,upstream:BladeRow, row:BladeRow) -> float:
+        """TD2_Pressure_Loss with Reynolds Correction Factor. This is from NASA SP-290 (Vol.1, p.62)
+    
+        The correlations come from td2-2.f Line 2771 
+        WYECOR(I)=WYECOR(I)*(0.35+0.65*18.21)/(0.35+0.65*(FLWP/VISC/RST(MEAN))**(0.2))
+        
+        I have assumed that 18.21 is some reference reynolds number. There is very little documentation on what these numbers are. The entire fortran code is frustrating and probably should never have happened in the first place. 
+
+        Args:
+            row (BladeRow): Current Blade Row
+        
+        Returns:
+            float: Total Pressure loss coefficient
+        """
+        Y = self.TD2(upstream,row)
+        A = 0.35
+        B = 0.65
+        Y = Y * (A+B*18.21)/(0.35+0.65*row.massflow/(row.mu* row.r.mean()))
+        row.Yp = Y
+        return Y
+    
+# def Soderberg(upstream:BladeRow,row:BladeRow) -> float: 
+#     """Soderberg Loss for axial machines. Takes into account the aspect ratio 
+
+#     Args:
+#         upstream (BladeRow): _description_
+#         row (BladeRow): _description_
+
+#     Returns:
+#         float: Enthalpy Loss Coefficients 
+#     """
+#     H = row.r.max()-row.r.min()
+#     l = row.x[-1]-row.x[0]
+#     xi = 0.04+0.06*((row.beta2-row.beta1)/100)**2 
+#     if row.row_type == RowType.Stator:
+#         mu = sutherland(row.T.mean())
+#         Re = row.rho*row.V*(l)/mu
+#         enthalpy_loss = (10E5/Re)**0.25 * ((1+xi)*(0.993+0.075*l/H)-1)
+#     else:
+#         mu = sutherland(row.T.mean())
+#         Re = row.rho*row.W*(row.x[-1]-row.x[0])/mu
+#         enthalpy_loss = (10E5/Re)**0.25 * ((1+xi)*(0.975+0.075*l/H)-1)
+#     return enthalpy_loss
+
+# def AinleyMathieson(upstream:BladeRow,row:BladeRow) -> float:
+#     """Ainley Mathieson equation for computing total pressure loss (Yp)
+
+#     Args:
+#         upstream (BladeRow): _description_
+#         row (BladeRow): _description_
+#     """
+#     #! Need to extract data from plots 
+#     pass 
+
+# def AinleyMathiesonUpdated(upstream:BladeRow,row:BladeRow) -> float:
+#     """Updated version of Ainley Mathieson
+#     https://www.mdpi.com/2504-186X/7/2/14
+#     These derivations are valid for steam turbines.
+
+#     Note:
+#         According to the authors, Pressure Loss divided in to 3 components: Profile Loss, secondary loss, and tip/shroud clearance loss
+
+#     Args:
+#         upstream (BladeRow): _description_
+#         row (BladeRow): _description_
+
+#     Returns:
+#         float: _description_
+#     """
+    
+#     pass 

turbodesign/loss/turbine/__init__.py

@@ -0,0 +1,8 @@
+
+from .craigcox import CraigCox
+from .TD2 import TD2, TD2_Reynolds_Correction
+from .ainleymathieson import AinleyMathieson
+from .fixedefficiency import FixedEfficiency
+from .fixedpressureloss import FixedPressureLoss
+from .kackerokapuu import KrackerOkapuu
+from .traupel import Traupel 

turbodesign/loss/turbine/ainleymathieson.py

@@ -0,0 +1,118 @@
+import pickle, os
+from typing import Dict
+from ...bladerow import BladeRow, sutherland
+from ...lossinterp import LossInterp
+from ...enums import RowType, LossType
+import numpy as np
+import pathlib
+from ..losstype import LossBaseClass
+
+class AinleyMathieson(LossBaseClass):
+        
+    def __init__(self):
+        """Ainley Mathieson loss correlation used for loss estimation for Gas and Steam Turbines. If you are designing an impulse turbine, this could be a good model to start with.
+        Use only with axial turbines. Loss correlations used with Reynolds numbers 1E5 to 3E5.
+        
+        Limitations:
+            - Doesn't factor incidence Loss. 
+            - Steamturbines
+            - Impulse Turbines beta1=alpha2
+            - Reynolds Range 
+            
+        Reference:
+            Ainley, D. G., and Mathieson, G. C. R., "A Method of Performance Estimation for Axial-Flow Turbines," British ARC, R & M 2974, 1951.
+
+        """
+        super().__init__(LossType.Pressure)
+        path = pathlib.Path(os.path.join(os.environ['TD3_HOME'],"ainleymathieson"+".pkl"))
+
+        if not path.exists():
+            print('Download file if doesn\'t exist')    
+        
+        with open(path.absolute(),'rb') as f:
+            self.data = pickle.load(f) # type: ignore
+            
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+        """Ainley Mathieson predicts the pressure loss of a turbine nozzle or rotor. Since these correlations are from Cascade experiments, the user should be familar with the reynolds and mach number requirements for each equation and figure. Using something outside the bounds can give inaccuare approximations of loss. Additionally these correlations were done on unoptimized blades so efficiencies maybe lower than what's attainable. Massflow can also be affected because exit P0 is affected. 
+        
+        This code will attempt use the correct equations and warn the user if mach number is out of range.
+        
+        Note:
+            alpha: gas flow angle relative to axial direction
+            beta: blade angle relative to axial direction 
+            
+        Args:
+            upstream (BladeRow): Upstream blade row
+            row (BladeRow): downstream blade row
+
+        Returns:
+            float: Pressure Loss at zero incidence 
+        """
+        Kp = 12300 # Ft / (pdl C); 1 pdl = 0.138254954376 N :(
+        At = row.throat
+        s = row.pitch
+        Area_upstream = np.pi*(upstream.r[-1]**2-upstream.r[0]**2)
+        Area_downstream = np.pi*(row.r[-1]**2-row.r[0]**2)
+        e = row.r.mean() # mean radius 
+        h = (row.r[-1]-row.r[0])
+        
+        s_c = row.pitch/row.chord
+        
+        if row.row_type == RowType.Stator:
+            k = 0
+            alpha1 = -np.abs(row.alpha1)
+            beta1 = -np.abs(np.radians(row.beta1_metal))
+            alpha2 = np.abs(row.alpha2)
+            if row.M<0.5:
+                alpha2 = self.data['Fig05'](np.degrees(np.cos(row.throat/row.pitch)))
+            elif row.M<0.95:
+                X = 0.7
+                alpha2 = np.arctan( 
+                                   ((1-X*k/h)*(np.cos(beta1)/np.cos(alpha2)))*np.tan(alpha2)
+                                   + X*k/h*np.cos(beta1)/np.cos(alpha2)*np.tan(beta1)
+                                   )    # Eqn 4
+            elif row.M<=1 and row.M>0.5:
+                if Area_upstream/Area_downstream <1.02 and Area_upstream/Area_downstream>0.98: # Not flared
+                    alpha2 = -np.arccos(At/Area_downstream) # Eqn 2
+                else: # Flared so use equation 3
+                    At = At/s * (5*Area_downstream + Area_upstream)/6 # Eqn 3
+            B = 0.25 # Eqn 6 
+        else:   # Rotor
+            k = row.tip_clearance
+            alpha1 = np.abs(row.beta1)
+            beta1 = np.abs(np.radians(row.beta1_metal))
+            alpha2 = -np.abs(row.beta2)
+            if row.M_rel<0.5:
+                alpha2 = self.data['Fig05'](np.degrees(np.cos(row.throat/row.pitch)))
+            elif row.M_rel<0.95:
+                X = 1.35 # Shrouded Blade
+                alpha2 = np.arctan( 
+                                   ((1-X*k/h)*(np.cos(beta1)/np.cos(alpha2)))*np.tan(alpha2)
+                                   + X*k/h*np.cos(beta1)/np.cos(alpha2)*np.tan(beta1)
+                                   )    # Eqn 4
+            elif row.M<=1.05 and row.M>=0.95:
+                alpha2 = -np.arccos(At/Area_downstream) # Eqn 2
+                
+            B = 0.5 # Eqn 6 
+            
+        
+        t_c = 0.2; # Impulse turbine 0.15 < t/c < 0.25    
+        
+        ID = (upstream.r[-1]+row.r[-1])/2; OD = (upstream.r[-1]+row.r[-1])/2
+        A1 = np.pi*(upstream.r[-1]**2 - upstream.r[0]**2)*np.cos(beta1)
+        A2 = np.pi*(row.r[-1]**2 - row.r[0]**2)*np.cos(alpha2)
+        lam = self.data['Fig08']((A2/A1)**2/(1+ID/OD)) # Eqn but using Figure 8
+        alpha_m = np.arctan((np.tan(alpha1) - np.tan(alpha2))/2)
+        Cl_s_c = 2*(np.tan(alpha1)-np.tan(alpha2))*np.cos(alpha_m)
+        # calculated but not used 
+        Y_secondary_clearance = (lam + B * k/h) * (Cl_s_c)**2 * (np.cos(alpha2)/np.cos(alpha_m)) # Eqn 6
+        
+        
+        Yp_beta0 = self.data['Fig04a'](s_c, np.degrees(alpha2))
+        Yp_beta1_eq_alpha2 = self.data['Fig04b'](s_c, np.degrees(alpha2))
+        
+        Yp_i0 = (Yp_beta0 + (beta1/alpha2)**2 *(Yp_beta1_eq_alpha2 - Yp_beta0)) *(t_c/0.2)**(-beta1/alpha2) # Fig 4 and Eqn 5
+        
+        Yt = Yp_i0 + Y_secondary_clearance 
+        return Yt   # Profile loss at zero incidence 
+