turbo-design 1.3.8__py3-none-any.whl → 1.3.10__py3-none-any.whl

turbodesign/{td_math.py → turbine_math.py}

@@ -1,86 +1,17 @@
-from typing import List, Optional
+from typing import List, Optional, Tuple
+import warnings
 import numpy as np
 import numpy.typing as npt
+from .isentropic import IsenP, IsenT
+from turbodesign.loss import losstype
 from .bladerow import BladeRow, compute_gas_constants
 from .enums import RowType, LossType
+from .outlet import OutletType
 from scipy.integrate import trapezoid
+from scipy.optimize import minimize
 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
-
-    Args:
-        coolant (Coolant): Coolant
-        massflow (np.ndarray): massflow mainstream
-
-    Returns:
-        float: Total Temperature drop
-    """
-    
-    massflow = row.massflow
-    total_massflow_no_coolant = row.total_massflow_no_coolant
-    Cp = row.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:
-        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()
-            Cp = row.Cp
-            T0R_new[1:] = (massflow[1:]*Cp*T0R[1:] + massflow_coolant*Cpc*T0c) \
-                        /(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 
-            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]+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-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
-            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.total_massflow = massflow[-1]
-    row.area = total_area
+from .flow_math import compute_massflow, compute_streamline_areas, compute_power
 
 def compute_reynolds(rows:List[BladeRow],passage:Passage):
     """Calculates the Reynolds Number 
@@ -90,7 +21,7 @@ def compute_reynolds(rows:List[BladeRow],passage:Passage):
         passage (Passage): Passage 
     """
     
-    for i in range(1,len(rows)):
+    for i in range(1,len(rows)-1):
         row = rows[i]
         xr = passage.get_xr_slice(0.5,(rows[i-1].location,row.percent_hub))
         dx = np.diff(xr[:,0])
@@ -105,39 +36,11 @@ def compute_reynolds(rows:List[BladeRow],passage:Passage):
             V = row.V.mean()
         rho = row.rho.mean()
         mu = row.mu
-        row.Reynolds = c*V*rho/mu
+        row.Reynolds = row.axial_chord*V*rho/mu
         row.mprime = mp
         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
-
-    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 
-        row.T0_is = 0 * row.T0 # Make it an array
-    else:
-        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 - row.T0)).mean()
-        # row.power = sum(v * w for v, w in zip(row.power[1:], np.diff(row.massflow))) # Massflow weighted average 
-        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()
-    
 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.
 
@@ -151,14 +54,14 @@ def compute_quantities(row:BladeRow,upstream:BladeRow):
         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: 
+
+        loss_type = getattr(row.loss_function, "loss_type", None)
+        if 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
@@ -167,7 +70,7 @@ def compute_quantities(row:BladeRow,upstream:BladeRow):
             row.power = np.trapezoid(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:
+        elif 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
@@ -195,7 +98,8 @@ def compute_quantities(row:BladeRow,upstream:BladeRow):
             
     elif row.row_type == RowType.Stator:
         ' For the stator we already assume the upstream P0 already applied '
-        if row.loss_function == LossType.Pressure:
+        loss_type = getattr(row.loss_function, "loss_type", None)
+        if loss_type == LossType.Pressure:
             row.P0 = upstream.P0 - row.Yp*(upstream.P0-row.P)
         else:
             row.P0 = upstream.P0
@@ -205,32 +109,45 @@ def compute_quantities(row:BladeRow,upstream:BladeRow):
         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:Optional[BladeRow]=None,calculate_vm:bool=True):
+def stator_calc(row:BladeRow,upstream:BladeRow,downstream:Optional[BladeRow]=None,calculate_vm:bool=True, outlet_type:OutletType=OutletType.static_pressure):
     """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 
-        
+        row.P = row.rp*(row.P0 - rotor.P) + rotor.P
+        Set alpha2
+
     Args:
         row (BladeRow): Stator Row
-        upstream (BladeRow): Stator or Rotor Row 
+        upstream (BladeRow): Stator or Rotor Row
         downstream (BladeRow): Stator or Rotor Row. Defaults to None
-         
+        calculate_vm (bool): True to calculate the meridional velocity. False, do not calculate this and let radeq calculate it
+        outlet_type (OutletType): OutletType.static_pressure if static conditions defined at outlet, OutletType.total_pressure if total conditions defined
     """
-    ## 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)
-    
+ 
+    # Static Pressure is assumed
+    T0_coolant = 0 
+    if row.coolant is not None:
+        T0_coolant = T0_coolant_weighted_average(row)
+    row.T0 = upstream.T0 - T0_coolant
+        
+    loss_type = getattr(row.loss_function, "loss_type", None)
+    if loss_type == LossType.Pressure:
+        row.P0 = upstream.P0 - row.Yp*(upstream.P0-row.P) # When static conditions are defined, use it to calculate P0
+       
+
+    elif loss_type == LossType.Enthalpy:
+        b = row.total_area * row.P0 / np.sqrt(row.T0) * np.sqrt(row.gamma/row.R)
+        solve_for_M = upstream.total_massflow / b
+        fun = lambda M : np.abs(solve_for_M - M*(1+(row.gamma-1)/2 * M**2) ** (-(row.gamma+1)/(2*(row.gamma-1))))
+        M_subsonic = minimize(fun,0.1, method='L-BFGS-B', bounds=[0,1])
+        M_supersonic = minimize(fun,1.5, method='L-BFGS-B', bounds=[1,5])
+        row.M = M_subsonic
+        row.T = row.T0/IsenT(M_subsonic,row.gamma)
+        a = np.sqrt(row.T*row.gamma*row.R)
+        row.P = row.total_massflow * row.R*row.T / (row.total_area * row.M * a) # Use the massflow to find static pressure 
+        
     if downstream is not None:
         row.P0_P = float((row.P0/downstream.P).mean())
         row.rp = ((row.P-downstream.P)/(upstream.P0-downstream.P)).mean()
@@ -239,7 +156,6 @@ def stator_calc(row:BladeRow,upstream:BladeRow,downstream:Optional[BladeRow]=Non
         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**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)
@@ -251,7 +167,6 @@ def stator_calc(row:BladeRow,upstream:BladeRow,downstream:Optional[BladeRow]=Non
         row.Vr = row.Vm*np.sin(row.phi)
         row.Vt = row.Vm*np.tan(row.alpha2)
         row.V = np.sqrt(row.Vx**2 + row.Vr**2 + row.Vt**2)
-        
         row.T = row.P/(row.R*row.rho)   # We know P, this is a guess
         row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
         
@@ -263,12 +178,14 @@ def stator_calc(row:BladeRow,upstream:BladeRow,downstream:Optional[BladeRow]=Non
     row.Wt = row.Vt-row.U
     row.P0_stator_inlet = upstream.P0
 
-def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
-    """Calculates quantities given beta2 
+def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True,outlet_type:OutletType=OutletType.static_pressure):
+    """Calculates quantities given beta2
 
     Args:
         row (BladeRow): Rotor Row
         upstream (BladeRow): Stator Row or Rotor Row
+        calculate_vm (bool): True to calculate the meridional velocity. False, do not calculate this and let radeq calculate it
+        outlet_type (OutletType): OutletType.static_pressure if static conditions defined at outlet, OutletType.total_pressure if total conditions defined
     """
     def _log_rotor_failure(reason:str):
         def _fmt(val):
@@ -294,10 +211,7 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
     ## 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).mean()
     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
@@ -306,17 +220,23 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
     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 
+    row.U = row.omega*row.r
+    
     if np.any(upstream_rothalpy < 0):
         print('U is too high, reduce RPM or radius')
+        
     # 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.T0R # (upstream_rothalpy + 0.5*row.U**2)/row.Cp # - T0_coolant_weighted_average(row) 
+    T0_coolant = 0 
+    if row.coolant is not None:
+        T0_coolant = T0_coolant_weighted_average(row)
+    row.T0R = (upstream_rothalpy + 0.5*row.U**2)/row.Cp - T0_coolant
     P0R_P = row.P0R / row.P
     T0R_T = P0R_P**((row.gamma-1)/row.gamma)
     row.T = (row.T0R/T0R_T)     # Exit static temperature
@@ -334,8 +254,8 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
                 reason += "; Yp > 0.3 This could be a problem with the loss model;"
             _log_rotor_failure(reason)
             raise ValueError(f'nan detected')
-        row.Vr = row.W*np.sin(row.phi)
         row.Vm = row.W*np.cos(row.beta2)
+        row.Vr = row.Vm*np.sin(row.phi)
         row.Wt = row.W*np.sin(row.beta2)
         row.Vx = row.Vm*np.cos(row.phi)
         row.Vt = row.Wt + row.U 
@@ -343,26 +263,34 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
         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.Vm)
-    else: # We know Vm, P0, T0
+    else: # We know Vm from radeq, beta2 from blade angle, T0R from rothalpy
         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))
+
+        # Compute W from velocity triangle (not thermodynamics) to close the triangle
+        row.W = row.Vm / np.cos(row.beta2)
         row.Wt = row.W*np.sin(row.beta2)
-        row.U = row.omega * row.r 
-        row.Vt = row.Wt+row.U
-        
+        row.U = row.omega * row.r
+        row.Vt = row.Wt + row.U
+
         row.alpha2 = np.arctan2(row.Vt,row.Vm)
         row.V = np.sqrt(row.Vm**2*(1+np.tan(row.alpha2)**2))
-        
+
+        # Update T from energy conservation in rotating frame
+        row.T = row.T0R - row.W**2 / (2*row.Cp)
+
         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))
-    
+
+    # Compute T0 first, then derive P0 from P0R to keep the velocity triangle consistent.
+    # P0/P0R = (T0/T0R)^(gamma/(gamma-1)) always holds since both reference the same static state.
+    # Using P0R (from the loss model) avoids dependence on the boundary-condition P, which may
+    # not be consistent with T after radeq adjusts Vm.
+    row.T0 = row.T + row.V**2/(2*row.Cp)
+    row.P0 = row.P0R * (row.T0 / row.T0R) ** (row.gamma / (row.gamma - 1))
+    row.P0_P = (row.P0_stator_inlet/row.P).mean()
+
     row.M_rel = row.W/np.sqrt(row.gamma*row.R*row.T)
-    row.T0 = row.T+row.V**2/(2*row.Cp)
 
 def inlet_calc(row:BladeRow):
     """Calculates the conditions for the Inlet 
@@ -370,40 +298,71 @@ 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.rho = row.P/(row.T*row.R)
-    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]
-            tube_massflow = row.massflow[j]-row.massflow[j-1]
-            if np.abs((row.x[j]-row.x[j-1]))<1E-6: # 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])
-        avg_mach = np.mean(row.M)
-        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.tan(row.alpha2)
-        row.V = np.sqrt(row.Vt**2+row.Vm**2)
-        # Fine tune the Temperature and Pressure and density
-        row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
-        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)
+    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)
         
-    if np.mean(row.M)>0.5:
-        raise ValueError(f"High inlet mach can lead to errors iter:{iter} Mach:{avg_mach}")
+    total_area, streamline_area = compute_streamline_areas(row)
+    row.total_area = total_area
+    row.area = streamline_area
+    Vm_tube = np.zeros(len(row.percent_hub_shroud)-1)
+    
+    Vm_mean = row.total_massflow / (row.rho.mean()*row.total_area)
+    for j in range(1,len(row.percent_hub_shroud)):
+        rho = row.rho[j]
+        Vm_tube[j-1] = (row.massflow[j]-row.massflow[j-1])/(rho*row.area[j])
+    
+    # Recover per-streamline Vm from tube-averaged Vm_tube assuming piecewise linear variation
+    row.Vm[0] = Vm_tube[0] if len(Vm_tube) else Vm_mean
+    for j in range(1, len(row.percent_hub_shroud)):
+        rho_bar = 0.5 * (row.rho[j] + row.rho[j-1])
+        Vm_tube_j = (row.massflow[j] - row.massflow[j-1]) / (rho_bar * row.area[j] + 1e-12)
+        row.Vm[j] = 2 * Vm_tube_j - row.Vm[j-1]
+
+    row.Vr = row.Vm*np.sin(row.phi)
+    row.V = row.M*np.sqrt(row.gamma*row.R*row.T)
+    row.Vt = row.V*np.sin(row.alpha2)
+    row.Vx = row.Vm*np.cos(row.phi)
+
+
+def T0_coolant_weighted_average(row:BladeRow) -> npt.NDArray:
+    """Calculate the new weighted Total Temperature array considering coolant
+
+    Args:
+        row (BladeRow): Coolant
+        massflow (np.ndarray): massflow mainstream
+
+    Returns:
+        float: Total Temperature drop
+    """
     
-    if np.mean(row.M)<0.01:
-        print(f"Unusually slow flow:{iter} Mach:{avg_mach}")
+    massflow = row.massflow
+    total_massflow_no_coolant = row.total_massflow_no_coolant
+    Cp = row.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:
+        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:   # Rotor use relative total temperature
+            T0R = row.T0R
+            T0R_new = T0R.copy()
+            Cp = row.Cp
+            T0R_new[1:] = (massflow[1:]*Cp*T0R[1:] + massflow_coolant*Cpc*T0c) \
+                        /(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 
+            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